a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4muRatio()));
990 } else {
991 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4muRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrH4muRatio()));
1005 } else {
1006 return (myNPbase->BrHZgamumuRatio()) / (myNPbase->BrH4muRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
1020 } else {
1021 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
1022 }
1023}
1024
1026{
1027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1028 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1029}
1030
1032{
1033 if ((this->getModel()).isModelLinearized()) {
1034 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1035 } else {
1036 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1037 }
1038}
1039
1040
1042{
1043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1044 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1045}
1046
1048{
1049 if ((this->getModel()).isModelLinearized()) {
1050 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1051 } else {
1052 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1053 }
1054}
1055
1056
1058{
1059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1060 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1061}
1062
1064{
1065 if ((this->getModel()).isModelLinearized()) {
1066 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1067 } else {
1068 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1069 }
1070}
1071
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1083 } else {
1084 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1098 } else {
1099 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1113 } else {
1114 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1128 } else {
1129 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1149{
1150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1151 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1152}
1153
1155{
1156 if ((this->getModel()).isModelLinearized()) {
1157 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1158 } else {
1159 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1160 }
1161}
1162
1164{
1165 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1166 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1167}
1168
1170{
1171 if ((this->getModel()).isModelLinearized()) {
1172 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1173 } else {
1174 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1175 }
1176}
1177
1178
1180{
1181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1182 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1183}
1184
1186{
1187 if ((this->getModel()).isModelLinearized()) {
1188 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1189 } else {
1190 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1191 }
1192}
1193
1194
1196{
1197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1198 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1199}
1200
1202{
1203 if ((this->getModel()).isModelLinearized()) {
1204 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1205 } else {
1206 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1207 }
1208}
1209
1210
1212{
1213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1214 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1215}
1216
1218{
1219 if ((this->getModel()).isModelLinearized()) {
1220 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1221 } else {
1222 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1223 }
1224}
1225
1226
1228{
1229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1230 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1231}
1232
1234{
1235 if ((this->getModel()).isModelLinearized()) {
1236 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1237 } else {
1238 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1239 }
1240}
1241
1242
1244{
1245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1246 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1247}
1248
1250{
1251 if ((this->getModel()).isModelLinearized()) {
1252 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1253 } else {
1254 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1255 }
1256}
1257
1258
1259// -----------------------------------------------------------------------------
1260// Full signal strengths (prod x decay)
1261// -----------------------------------------------------------------------------
1262
1263muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1265{
1266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1267 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1268}
1269
1271{
1272 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1273 //AG: Most general expression including quadratic corrections.
1274 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1275 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1276 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1277 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1278 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1279 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1280
1281 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1282 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1286 } else {
1287 return myNPbase->muggHgaga(sqrt_s);
1288 }
1289}
1290
1291muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1293{
1294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1295 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1296}
1297
1299{
1301}
1302
1303muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1305{
1306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1307 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1308}
1309
1311{
1312 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1313 //AG: Most general expression including quadratic corrections.
1314 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1315 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1316 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1317 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1318 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1319 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1320
1321 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1322 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1325
1326 double mu;
1327
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1329
1330 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1331
1332 return mu;
1333 } else {
1334 return myNPbase->muVBFHgaga(sqrt_s);
1335 }
1336}
1337
1338muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1340{
1341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1342 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1343}
1344
1346{
1347 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1348 //AG: Most general expression including quadratic corrections.
1349 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1350 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1351 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1352 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1353 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1354 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1355
1356 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1357 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1360
1361 double mu;
1362
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1364
1365 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1366
1367 return mu;
1368
1369 } else {
1370 return myNPbase->muZHgaga(sqrt_s);
1371 }
1372}
1373
1374muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1376{
1377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1378 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1379}
1380
1382{
1383 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1384 //AG: Most general expression including quadratic corrections.
1385 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1386 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1387 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1388 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1389 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1390 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1391
1392 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1393 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1396
1397 double mu;
1398
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1400
1401 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1402
1403 return mu;
1404
1405 } else {
1406 return myNPbase->muWHgaga(sqrt_s);
1407 }
1408}
1409
1410muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1411: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1412{
1413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1414 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1415}
1416
1418{
1419 if ((this->getModel()).isModelLinearized()) {
1420 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1421 } else {
1422 return myNPbase->muVHgaga(sqrt_s);
1423 }
1424}
1425
1426muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1427: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1428{
1429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1430 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1431}
1432
1434{
1435 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1436 //AG: Most general expression including quadratic corrections.
1437 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1438 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1439 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1440 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1441 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1442 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1443
1444 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1445 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1448
1449 double mu;
1450
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1452
1453 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1454
1455 return mu;
1456
1457 } else {
1458 return myNPbase->muttHgaga(sqrt_s);
1459 }
1460}
1461
1462mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1464{
1465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1466 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1467}
1468
1470{
1471 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1472 //AG: Most general expression including quadratic corrections.
1473 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1474 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1475 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1476 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1477 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1478
1479 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1480 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1483
1484 double mu;
1485
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1487
1488 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1489
1490 return mu;
1491
1492 } else {
1493 //VM: Just in case someone wants to add directly the production*decay
1494 //(which is the observable we fit at the end)
1495 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1496 if(NPmutHgaga==1.0){
1497 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1498 } else{
1499 return NPmutHgaga;
1500 }
1501 }
1502}
1503
1504muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1505: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1506{
1507 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1508 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1509}
1510
1512{
1513 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1514 //AG: Most general expression including quadratic corrections.
1515 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1516 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1517 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1518 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1519 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1520
1521 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1522 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1525
1526 double mu;
1527
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1529
1530 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1531
1532 return mu;
1533
1534 } else {
1535 //VM: Just in case someone wants to add directly the production*decay
1536 //(which is the observable we fit at the end)
1537 //Also, the bbH is missing here, I'll leave it as it was for the
1538 //moment (since bbH is really suppressed).
1539 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1541 return (myNPbase->muggHgaga(sqrt_s));
1542 } else{
1543 return NPmuggHpbbH_Hgaga;
1544 }
1545 }
1546}
1547
1548muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1549: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1550{
1551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1552 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1553}
1554
1556{
1557 //VM:Note that these values are valid for 13 TeV, they are not general
1558 //We should access the SM function that has all the values (for the
1559 //different energies). The values are slightly different, we should
1560 //check this.
1561 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1564 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1565 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1566
1567 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1568 //AG: Most general expression including quadratic corrections.
1569 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1570 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1571 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1572 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1573 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1574
1575 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1576 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1579
1580 double mu;
1581
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1583
1584 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1585
1586 return mu;
1587
1588 } else {
1589 //VM: Just in case someone wants to add directly the production*decay
1590 //(which is the observable we fit at the end)
1591 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1592 if(NPmuttHptH_Hgaga==1.0){
1593 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1594 } else {
1595 return NPmuttHptH_Hgaga;
1596 }
1597 }
1598}
1599
1600muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1602{
1603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1604 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1605}
1606
1608{
1609 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1610 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1611 //AG: Most general expression including quadratic corrections.
1612 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1613 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1614 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1615 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1616 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1617
1618 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1619 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1622
1623 double mu;
1624
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1626
1627 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1628
1629 return mu;
1630
1631 } else {
1632 return myNPbase->muggHZga(sqrt_s);
1633 }
1634}
1635
1636muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1637: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1638{
1639 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1640 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1641}
1642
1644{
1645 if ((this->getModel()).isModelLinearized()) {
1646 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1647 } else {
1649 }
1650}
1651
1652muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1654{
1655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1656 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1657}
1658
1660{
1661 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1662 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1663 //AG: Most general expression including quadratic corrections.
1664 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1665 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1666 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1667 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1668 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1669
1670 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1671 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1674
1675 double mu;
1676
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1678
1679 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1680
1681 return mu;
1682
1683 } else {
1684 return myNPbase->muVBFHZga(sqrt_s);
1685 }
1686}
1687
1688muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1690{
1691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1692 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1693}
1694
1696{
1697 if ((this->getModel()).isModelLinearized()) {
1698 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1699 } else {
1700 return myNPbase->muZHZga(sqrt_s);
1701 }
1702}
1703
1704muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1706{
1707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1708 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1709}
1710
1712{
1713 if ((this->getModel()).isModelLinearized()) {
1714 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1715 } else {
1716 return myNPbase->muWHZga(sqrt_s);
1717 }
1718}
1719
1720muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1722{
1723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1724 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1725}
1726
1728{
1729 if ((this->getModel()).isModelLinearized()) {
1730 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1731 } else {
1732 return myNPbase->muVHZga(sqrt_s);
1733 }
1734}
1735
1736muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1737: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1738{
1739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1740 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1741}
1742
1744{
1745 if ((this->getModel()).isModelLinearized()) {
1746 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1747 } else {
1748 return myNPbase->muttHZga(sqrt_s);
1749 }
1750}
1751
1752muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1753: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1754{
1755 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1756 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1757}
1758
1760{
1761 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1762 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1763 //AG: Most general expression including quadratic corrections.
1764 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1765 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1766 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1767 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1768 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1769
1770 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1771 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1772 double Br1 = dGammaR1-dGammaRTot1;
1773 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1774
1775 double mu;
1776
1777 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1778
1779 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1780
1781 return mu;
1782
1783 } else {
1784 return myNPbase->muggHZZ(sqrt_s);
1785 }
1786}
1787
1788muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1789: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1790{
1791 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1792 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1793}
1794
1796{
1797 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1798 //AG: Most general expression including quadratic corrections.
1799 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1800 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1801 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1802 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1803 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1804 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1805
1806 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1807 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1808 double Br1 = dGammaR1-dGammaRTot1;
1809 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1810
1811 double mu;
1812
1813 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1814
1815 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1816
1817 return mu;
1818
1819 } else {
1820 return myNPbase->muVBFHZZ(sqrt_s);
1821 }
1822}
1823
1824muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1825: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1826{
1827 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1828 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1829}
1830
1832{
1833 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1834 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1835 //AG: Most general expression including quadratic corrections.
1836 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1837 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1838 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1839 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1840 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1841
1842 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1843 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1844 double Br1 = dGammaR1-dGammaRTot1;
1845 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1846
1847 double mu;
1848
1849 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1850
1851 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1852
1853 return mu;
1854
1855 } else {
1856 return myNPbase->muZHZZ(sqrt_s);
1857 }
1858}
1859
1860muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1862{
1863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1864 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1865}
1866
1868{
1869 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1870 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1871 //AG: Most general expression including quadratic corrections.
1872 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1873 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1874 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1875 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1876 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1877
1878 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1879 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1880 double Br1 = dGammaR1-dGammaRTot1;
1881 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1882
1883 double mu;
1884
1885 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1886
1887 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1888
1889 return mu;
1890
1891 } else {
1892 return myNPbase->muWHZZ(sqrt_s);
1893 }
1894}
1895
1896muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1897: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1898{
1899 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1900 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1901}
1902
1904{
1905 //VM:Note that these values are valid for 13 TeV, they are not general
1906 //We should access the SM function that has all the values (for the
1907 //different energies). The values are slightly different, we should
1908 //check this.
1909 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1910 double xsSM_WH = 1.21539;
1911 double xsSM_ZH = 0.795910;
1912 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1913 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1914 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1915 //AG: Most general expression including quadratic corrections.
1916 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1917 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1918 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1919 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1920 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1921 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1922
1923 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1924 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1925 double Br1 = dGammaR1-dGammaRTot1;
1926 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1927
1928 double mu;
1929
1930 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1931
1932 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1933
1934 return mu;
1935
1936 } else {
1937 //return myNPbase->muVHZZ(sqrt_s);
1938 //VM: Just in case someone wants to add directly the production*decay
1939 //(which is the observable we fit at the end)
1940 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1941 if(NPmuVHZZ==1.0){
1942 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1943 } else {
1944 return NPmuVHZZ;
1945 }
1946 }
1947}
1948
1949muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1950: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1951{
1952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1953 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1954}
1955
1957{
1958 if ((this->getModel()).isModelLinearized()) {
1959 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1960 } else {
1961 return myNPbase->muttHZZ(sqrt_s);
1962 }
1963}
1964
1965muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1966: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1967{
1968 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1969 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1970}
1971
1973{
1974 //VM:Note that these values are valid for 13 TeV, they are not general
1975 //We should access the SM function that has all the values (for the
1976 //different energies). The values are slightly different, we should
1977 //check this.
1978 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1979 double xsSM_ttH = 0.499873;
1980 double xsSM_tH = 0.0821;
1981 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1982 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1983 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1984 //AG: Most general expression including quadratic corrections.
1985 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1986 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1987 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1988 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1989 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1990 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1991
1992 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1993 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1994 double Br1 = dGammaR1-dGammaRTot1;
1995 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1996
1997 double mu;
1998
1999 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2000
2001 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2002
2003 return mu;
2004
2005 } else {
2006
2007 //VM: Just in case someone wants to add directly the production*decay
2008 //(which is the observable we fit at the end)
2009 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
2010 if(NPmuttHptH_HZZ==1.0){
2011 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
2012 } else {
2013 return NPmuttHptH_HZZ;
2014 }
2015 }
2016}
2017
2018muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
2019: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2020{
2021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2022 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
2023}
2024
2026{
2027 //VM:Note that these values are valid for 13 TeV, they are not general
2028 //We should access the SM function that has all the values (for the
2029 //different energies). The values are slightly different, we should
2030 //check this.
2031 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2032 double xsSM_ttH = 0.499873;
2033 double xsSM_tH = 0.0821;
2034 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2035 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2036 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2037 //return ( 1.0
2038 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2039 // + (myNPbase->BrHmumuRatio()-1.));
2040 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2041 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2042 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2043 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2044
2045 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2046 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2047 double Br1 = dGammaR1-dGammaRTot1;
2048 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2049
2050 double mu;
2051
2052 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2053
2054 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2055
2056 return mu;
2057
2058 } else {
2059
2060 //VM: Just in case someone wants to add directly the production*decay
2061 //(which is the observable we fit at the end)
2062 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2063 if(NPmuttHptH_Hmumu==1.0){
2064 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2065 } else {
2066 return NPmuttHptH_Hmumu;
2067 }
2068 }
2069}
2070
2071muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2072: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2073{
2074 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2075 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2076}
2077
2079{
2080 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2081 //AG: Most general expression including quadratic corrections.
2082 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2083 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2084 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2085 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2086 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2087 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2088
2089 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2090 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2091 double Br1 = dGammaR1-dGammaRTot1;
2092 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2093
2094 double mu;
2095
2096 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2097
2098 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2099
2100 return mu;
2101
2102 } else {
2103 //VM: Just in case someone wants to add directly the production*decay
2104 //(which is the observable we fit at the end)
2105 //Also, the bbH is missing here, I'll leave it as it was for the
2106 //moment (since bbH is really suppressed in the SM).
2107 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2108 if (NPmuggHpbbH_HZZ == 1.0){
2109 return (myNPbase->muggHZZ(sqrt_s));
2110 } else{
2111 return NPmuggHpbbH_HZZ;
2112 }
2113 }
2114}
2115
2116muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2118{
2119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2120 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2121}
2122
2124{
2125 if ((this->getModel()).isModelLinearized()) {
2126 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2127 } else {
2128 return myNPbase->muggHZZ4l(sqrt_s);
2129 }
2130}
2131
2132muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2133: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2134{
2135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2136 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2137}
2138
2140{
2141 if ((this->getModel()).isModelLinearized()) {
2142 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2143 } else {
2144 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2145 }
2146}
2147
2148muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2150{
2151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2152 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2153}
2154
2156{
2157 if ((this->getModel()).isModelLinearized()) {
2158 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2159 } else {
2160 return myNPbase->muVBFHZZ4l(sqrt_s);
2161 }
2162}
2163
2164muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2166{
2167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2168 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2169}
2170
2172{
2173 if ((this->getModel()).isModelLinearized()) {
2174 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2175 } else {
2176 return myNPbase->muZHZZ4l(sqrt_s);
2177 }
2178}
2179
2180muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2181: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2182{
2183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2184 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2185}
2186
2188{
2189 if ((this->getModel()).isModelLinearized()) {
2190 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2191 } else {
2192 return myNPbase->muWHZZ4l(sqrt_s);
2193 }
2194}
2195
2196muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2197: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2198{
2199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2200 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2201}
2202
2204{
2205 if ((this->getModel()).isModelLinearized()) {
2206 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2207 } else {
2208 return myNPbase->muVHZZ4l(sqrt_s);
2209 }
2210}
2211
2212muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2213: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2214{
2215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2216 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2217}
2218
2220{
2221 if ((this->getModel()).isModelLinearized()) {
2222 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2223 } else {
2224 return myNPbase->muttHZZ4l(sqrt_s);
2225 }
2226}
2227
2228muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2229: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2230{
2231 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2232 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2233}
2234
2236{
2237 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2238 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2239 //AG: Most general expression including quadratic corrections.
2240 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2241 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2242 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2243 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2244 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2245
2246 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2247 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2248 double Br1 = dGammaR1-dGammaRTot1;
2249 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2250
2251 double mu;
2252
2253 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2254
2255 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2256
2257 return mu;
2258
2259 } else {
2260 return myNPbase->muggHWW(sqrt_s);
2261 }
2262}
2263
2264muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2265: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2266{
2267 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2268 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2269}
2270
2272{
2273 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2274 //AG: Most general expression including quadratic corrections.
2275 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2276 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2277 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2278 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2279 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2280 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2281
2282 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2283 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2284 double Br1 = dGammaR1-dGammaRTot1;
2285 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2286
2287 double mu;
2288
2289 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2290
2291 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2292
2293 return mu;
2294
2295 } else {
2296 return myNPbase->muVBFHWW(sqrt_s);
2297 }
2298}
2299
2300muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2301: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2302{
2303 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2304 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2305}
2306
2308{
2309 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2310 //AG: Most general expression including quadratic corrections.
2311 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2312 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2313 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2314 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2315 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2316 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2317
2318 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2319 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2320 double Br1 = dGammaR1-dGammaRTot1;
2321 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2322
2323 double mu;
2324
2325 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2326
2327 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2328
2329 return mu;
2330
2331 } else {
2332 return myNPbase->muZHWW(sqrt_s);
2333 }
2334}
2335
2336muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2337: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2338{
2339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2340 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2341}
2342
2344{
2345 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2346 //AG: Most general expression including quadratic corrections.
2347 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2348 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2349 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2350 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2351 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2352 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2353
2354 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2355 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2356 double Br1 = dGammaR1-dGammaRTot1;
2357 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2358
2359 double mu;
2360
2361 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2362
2363 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2364
2365 return mu;
2366
2367 } else {
2368 return myNPbase->muWHWW(sqrt_s);
2369 }
2370}
2371
2372muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2373: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2374{
2375 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2376 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2377}
2378
2380{
2381 if ((this->getModel()).isModelLinearized()) {
2382 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2383 } else {
2384 return myNPbase->muVHWW(sqrt_s);
2385 }
2386}
2387
2388muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2389: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2390{
2391 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2392 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2393}
2394
2396{
2397 if ((this->getModel()).isModelLinearized()) {
2398 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2399 } else {
2400 return myNPbase->muttHWW(sqrt_s);
2401 }
2402}
2403
2404muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2406{
2407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2408 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2409}
2410
2412{
2413
2414 //VM:Note that these values are valid for 13 TeV, they are not general
2415 //We should access the SM function that has all the values (for the
2416 //different energies). The values are slightly different, we should
2417 //check this.
2418 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2419 double xsSM_ttH = 0.499873;
2420 double xsSM_tH = 0.0821;
2421 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2422 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2423 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2424 //AG: Most general expression including quadratic corrections.
2425 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2426 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2427 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2428 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2429 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2430
2431 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2432 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2433 double Br1 = dGammaR1-dGammaRTot1;
2434 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2435
2436 double mu;
2437
2438 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2439
2440 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2441
2442 return mu;
2443
2444 } else {
2445
2446 //VM: Just in case someone wants to add directly the production*decay
2447 //(which is the observable we fit at the end)
2448 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2449 if(NPmuttHptH_HWW==1.0){
2450 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2451 } else {
2452 return NPmuttHptH_HWW;
2453 }
2454 }
2455}
2456
2457muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2458: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2459{
2460 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2461 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2462}
2463
2465{
2466 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2467 //AG: Most general expression including quadratic corrections.
2468 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2469 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2470 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2471 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2472 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2473 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2474
2475 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2476 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2477 double Br1 = dGammaR1-dGammaRTot1;
2478 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2479
2480 double mu;
2481
2482 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2483
2484 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2485
2486 return mu;
2487
2488 } else {
2489
2490 //VM: Just in case someone wants to add directly the production*decay
2491 //(which is the observable we fit at the end)
2492 //Also, the bbH is missing here, I'll leave it as it was for the
2493 //moment (since bbH is really suppressed in the SM).
2494 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2495 if (NPmuggHpbbH_HWW == 1.0){
2496 return (myNPbase->muggHWW(sqrt_s));
2497 } else{
2498 return NPmuggHpbbH_HWW;
2499 }
2500 }
2501}
2502
2503muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2504: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2505{
2506 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2507 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2508}
2509
2511{
2512 if ((this->getModel()).isModelLinearized()) {
2513 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2514 } else {
2515 return myNPbase->muggHWW2l2v(sqrt_s);
2516 }
2517}
2518
2519muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2520: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2521{
2522 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2523 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2524}
2525
2527{
2528 if ((this->getModel()).isModelLinearized()) {
2529 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2530 } else {
2531 return myNPbase->muVBFHWW2l2v(sqrt_s);
2532 }
2533}
2534
2535muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2537{
2538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2539 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2540}
2541
2543{
2544 if ((this->getModel()).isModelLinearized()) {
2545 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2546 } else {
2547 return myNPbase->muZHWW2l2v(sqrt_s);
2548 }
2549}
2550
2551muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2552: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2553{
2554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2555 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2556}
2557
2559{
2560 if ((this->getModel()).isModelLinearized()) {
2561 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2562 } else {
2563 return myNPbase->muWHWW2l2v(sqrt_s);
2564 }
2565}
2566
2567muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2568: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2569{
2570 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2571 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2572}
2573
2575{
2576 if ((this->getModel()).isModelLinearized()) {
2577 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2578 } else {
2579 return myNPbase->muVHWW2l2v(sqrt_s);
2580 }
2581}
2582
2583muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2584: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2585{
2586 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2587 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2588}
2589
2591{
2592 if ((this->getModel()).isModelLinearized()) {
2593 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2594 } else {
2595 return myNPbase->muttHWW2l2v(sqrt_s);
2596 }
2597}
2598
2599muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2600: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2601{
2602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2603 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2604}
2605
2607{
2608 if ((this->getModel()).isModelLinearized()) {
2609 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2610 } else {
2611 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2612 }
2613}
2614
2615muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2616: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2617{
2618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2619 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2620}
2621
2623{
2624 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2625 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2626 //AG: Most general expression including quadratic corrections.
2627 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2628 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2629 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2630 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2631 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2632
2633 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2634 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2635 double Br1 = dGammaR1-dGammaRTot1;
2636 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2637
2638 double mu;
2639
2640 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2641
2642 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2643
2644 return mu;
2645
2646 } else {
2647 return myNPbase->muggHmumu(sqrt_s);
2648 }
2649}
2650
2651muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2652: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2653{
2654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2655 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2656}
2657
2659{
2660 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2661 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2662 //AG: Most general expression including quadratic corrections.
2663 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2664 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2665 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2666 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2667 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2668
2669 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2670 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2671 double Br1 = dGammaR1-dGammaRTot1;
2672 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2673
2674 double mu;
2675
2676 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2677
2678 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2679
2680 return mu;
2681
2682 } else {
2683 return myNPbase->muVBFHmumu(sqrt_s);
2684 }
2685}
2686
2687muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2688: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2689{
2690 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2691 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2692}
2693
2695{
2696 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2697 //AG: Most general expression including quadratic corrections.
2698 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2699 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2700 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2701 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2702 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2703
2704 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2705 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2706 double Br1 = dGammaR1-dGammaRTot1;
2707 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2708
2709 double mu;
2710
2711 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2712
2713 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2714
2715 return mu;
2716
2717 } else {
2718 return myNPbase->muZHmumu(sqrt_s);
2719 }
2720}
2721
2722muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2724{
2725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2726 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2727}
2728
2730{
2731 if ((this->getModel()).isModelLinearized()) {
2732 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2733 } else {
2734 return myNPbase->muWHmumu(sqrt_s);
2735 }
2736}
2737
2738muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2739: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2740{
2741 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2742 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2743}
2744
2746{
2747
2748 //VM:Note that these values are valid for 13 TeV, they are not general
2749 //We should access the SM function that has all the values (for the
2750 //different energies). The values are slightly different, we should
2751 //check this.
2752 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2753 double xsSM_WH = 1.21539;
2754 double xsSM_ZH = 0.795910;
2755 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2756 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2757 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2758 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2759 //AG: Most general expression including quadratic corrections.
2760 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2761 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2762 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2763 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2764 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2765
2766 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2767 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2768 double Br1 = dGammaR1-dGammaRTot1;
2769 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2770
2771 double mu;
2772
2773 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2774
2775 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2776
2777 return mu;
2778
2779 } else {
2780 //return myNPbase->muVHmumu(sqrt_s);
2781 //VM: Just in case someone wants to add directly the production*decay
2782 //(which is the observable we fit at the end)
2783 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2784 if(NPmuVHmumu==1.0){
2785 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2786 } else {
2787 return NPmuVHmumu;
2788 }
2789
2790 }
2791}
2792
2793muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2794: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2795{
2796 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2797 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2798}
2799
2801{
2802 if ((this->getModel()).isModelLinearized()) {
2803 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2804 } else {
2805 return myNPbase->muttHmumu(sqrt_s);
2806 }
2807}
2808
2809muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2810: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2811{
2812 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2813 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2814}
2815
2817{
2818 //VM:Note that these values are valid for 13 TeV, they are not general
2819 //We should access the SM function that has all the values (for the
2820 //different energies). The values are slightly different, we should
2821 //check this. Furthermore, the bbH is not included. In the SM this is
2822 //very suppressed (and it's probably also the case in the SMEFT) but
2823 //in some NP models it may not be the case.Unfortunately, bbH is not
2824 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2825 //SMEFT and add here the general expression.
2826 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2827 double xsSM_ggHbbH = 44.745;
2828 double xsSM_ttH = 0.4998;
2829 double xsSM_tH = 0.084769;
2830 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2831 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2832 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2833 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2834
2835
2836
2837 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2838 //AG: Most general expression including quadratic corrections.
2839 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2840 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2841 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2842 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2843 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2844
2845 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2846 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2847 double Br1 = dGammaR1-dGammaRTot1;
2848 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2849
2850 double mu;
2851
2852 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2853
2854 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2855
2856 return mu;
2857
2858 } else {
2859
2860 //VM: Just in case someone wants to add directly the production*decay
2861 //(which is the observable we fit at the end). Furthermore, the Hbb
2862 //is not added in the original formula, fine for the SM (probably also
2863 //for the SMEFT) but not for all NP models.
2864 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2865 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2866 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2867 } else {
2868 return NPmuggHpttHptHpbbH_Hmumu;
2869 }
2870 }
2871}
2872
2873muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2874: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2875{
2876 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2877 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2878}
2879
2881{
2882
2883 //VM:Note that these values are valid for 13 TeV, they are not general
2884 //We should access the SM function that has all the values (for the
2885 //different energies). The values are slightly different, we should
2886 //check this.
2887 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2888 double xsSM_VBF = 3.49948;
2889 double xsSM_WH = 1.21539;
2890 double xsSM_ZH = 0.795910;
2891 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2892 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2893 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2894 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2895 //AG: Most general expression including quadratic corrections.
2896 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2897 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2898 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2899 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2900 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2901
2902 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2903 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2904 double Br1 = dGammaR1-dGammaRTot1;
2905 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2906
2907 double mu;
2908
2909 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2910
2911 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2912
2913 return mu;
2914
2915 } else {
2916
2917 //VM: Just in case someone wants to add directly the production*decay
2918 //(which is the observable we fit at the end).
2919 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2920 if(NPmuVBFpVH_Hmumu==1.0){
2921 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2922 } else {
2923 return NPmuVBFpVH_Hmumu;
2924 }
2925 }
2926}
2927
2928muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2929: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2930{
2931 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2932 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2933}
2934
2936{
2937 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2938 //AG: Most general expression including quadratic corrections.
2939 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2940 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2941 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2942 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2943 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2944 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2945
2946 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2947 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2948 double Br1 = dGammaR1-dGammaRTot1;
2949 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2950
2951 double mu;
2952
2953 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2954
2955 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2956
2957 return mu;
2958
2959 } else {
2960 return myNPbase->muggHtautau(sqrt_s);
2961 }
2962}
2963
2964muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2965: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2966{
2967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2968 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2969}
2970
2972{
2973 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2974 //AG: Most general expression including quadratic corrections.
2975 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2976 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2977 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2978 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2979 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2980 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2981
2982 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2983 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2984 double Br1 = dGammaR1-dGammaRTot1;
2985 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2986
2987 double mu;
2988
2989 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2990
2991 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2992
2993 return mu;
2994
2995 } else {
2996 return myNPbase->muVBFHtautau(sqrt_s);
2997 }
2998}
2999
3000
3001
3002muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3004{
3005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3006 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
3007}
3008
3010{
3011 if ((this->getModel()).isModelLinearized()) {
3012 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3013 } else {
3015 }
3016}
3017
3018
3019muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3021{
3022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3023 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
3024}
3025
3026double muZHtautau::computeThValue() //AG:modified
3027{
3028 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3029 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3030 //AG: Most general expression including quadratic corrections.
3031 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3032 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3033 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3034 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3035 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3036 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3037
3038 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3039 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3040 double Br1 = dGammaR1-dGammaRTot1;
3041 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3042
3043 double mu;
3044
3045 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3046
3047 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3048
3049 return mu;
3050
3051 } else {
3052 return myNPbase->muZHtautau(sqrt_s);
3053 }
3054}
3055
3056muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3058{
3059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3060 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3061}
3062
3064{
3065 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3066 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3067 //AG: Most general expression including quadratic corrections.
3068 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3069 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3070 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3071 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3072 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3073
3074 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3075 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3076 double Br1 = dGammaR1-dGammaRTot1;
3077 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3078
3079 /*std::cout << "muProd1="<<muProd1<<std::endl;
3080 std::cout << "muProd2="<<muProd2<<std::endl;
3081 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3082 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3083 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3084 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3085
3086 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3087 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3088
3089 double mu;
3090
3091 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3092
3093 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3094
3095 return mu;
3096
3097 } else {
3098 return myNPbase->muWHtautau(sqrt_s);
3099 }
3100}
3101
3102muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3104{
3105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3106 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3107}
3108
3110{
3111 //VM:Note that these values are valid for 13 TeV, they are not general
3112 //We should access the SM function that has all the values (for the
3113 //different energies). The values are slightly different, we should
3114 //check this.
3115 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3116 double xsSM_WH = 1.21539;
3117 double xsSM_ZH = 0.795910;
3118 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3119 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3120 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3121 //AG: Most general expression including quadratic corrections.
3122 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3123 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3124 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3125 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3126 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3127 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3128
3129 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3130 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3131 double Br1 = dGammaR1-dGammaRTot1;
3132 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3133
3134 double mu;
3135
3136 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3137
3138 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3139
3140 return mu;
3141
3142 } else {
3143 //return myNPbase->muVHtautau(sqrt_s);
3144
3145 //VM: Just in case someone wants to add directly the production*decay
3146 //(which is the observable we fit at the end)
3147 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3148 if(NPmuVHtautau==1.0){
3149 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3150 } else {
3151 return NPmuVHtautau;
3152 }
3153 }
3154}
3155
3156muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3157: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3158{
3159 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3160 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3161}
3162
3164{
3165 if ((this->getModel()).isModelLinearized()) {
3166 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3167 } else {
3168 return myNPbase->muttHtautau(sqrt_s);
3169 }
3170}
3171
3172muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3173: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3174{
3175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3176 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3177}
3178
3180{
3181 //VM:Note that these values are valid for 13 TeV, they are not general
3182 //We should access the SM function that has all the values (for the
3183 //different energies). The values are slightly different, we should
3184 //check this.
3185 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3186 double xsSM_ttH = 0.499873;
3187 double xsSM_tH = 0.0821;
3188 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3189 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3190 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3191 //AG: Most general expression including quadratic corrections.
3192 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3193 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3194 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3195 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3196 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3197
3198 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3199 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3200 double Br1 = dGammaR1-dGammaRTot1;
3201 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3202
3203 double mu;
3204
3205 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3206
3207 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3208
3209 return mu;
3210
3211 } else {
3212
3213 //VM: Just in case someone wants to add directly the production*decay
3214 //(which is the observable we fit at the end)
3215 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3216 if(NPmuttHptH_Htautau==1.0){
3217 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3218 } else {
3219 return NPmuttHptH_Htautau;
3220 }
3221
3222 }
3223}
3224
3225muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3226: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3227{
3228 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3229 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3230}
3231
3233{
3234 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3235 //AG: Most general expression including quadratic corrections.
3236 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3237 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3238 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3239 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3240 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3241 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3242
3243 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3244 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3245 double Br1 = dGammaR1-dGammaRTot1;
3246 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3247
3248 double mu;
3249
3250 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3251
3252 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3253
3254 return mu;
3255
3256 } else {
3257
3258 //VM: Just in case someone wants to add directly the production*decay
3259 //(which is the observable we fit at the end)
3260 //Also, the bbH is missing here, I'll leave it as it was for the
3261 //moment (since bbH is really suppressed in the SM).
3262 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3263 if (NPmuggHpbbH_Htautau == 1.0){
3264 return (myNPbase->muggHtautau(sqrt_s));
3265 } else{
3266 return NPmuggHpbbH_Htautau;
3267 }
3268 }
3269}
3270
3271muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3272: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3273{
3274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3275 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3276}
3277
3279{
3280 if ((this->getModel()).isModelLinearized()) {
3281 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3282 //AG: Most general expression including quadratic corrections.
3283 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3284 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3285 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3286 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3287 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3288
3289 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3290 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3291 double Br1 = dGammaR1-dGammaRTot1;
3292 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3293
3294 double mu;
3295
3296 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3297
3298 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3299
3300 return mu;
3301
3302 } else {
3303 return myNPbase->muggHbb(sqrt_s);
3304 }
3305}
3306
3307muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3308: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3309{
3310 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3311 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3312}
3313
3315{
3316 if ((this->getModel()).isModelLinearized()) {
3317 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3318 } else {
3319 return myNPbase->muVBFHbb(sqrt_s);
3320 }
3321}
3322
3323muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3325{
3326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3327 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3328}
3329
3331{
3332 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3333 //AG: Most general expression including quadratic corrections.
3334 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3335 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3336 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3337 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3338 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3339 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3340
3341 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3342 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3343 double Br1 = dGammaR1-dGammaRTot1;
3344 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3345
3346 double mu;
3347
3348 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3349
3350 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3351
3352 return mu;
3353
3354 } else {
3355 return myNPbase->muZHbb(sqrt_s);
3356 }
3357}
3358
3359muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3360: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3361{
3362 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3363 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3364}
3365
3367{
3368 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3369 //AG: Most general expression including quadratic corrections.
3370 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3371 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3372 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3373 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3374 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3375 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3376
3377 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3378 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3379 double Br1 = dGammaR1-dGammaRTot1;
3380 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3381
3382 double mu;
3383
3384 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3385
3386 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3387
3388 return mu;
3389
3390 } else {
3391 return myNPbase->muWHbb(sqrt_s);
3392 }
3393}
3394
3395muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3397{
3398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3399 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3400}
3401
3403{
3404 if ((this->getModel()).isModelLinearized()) {
3405 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3406 } else {
3407 return myNPbase->muVHbb(sqrt_s);
3408 }
3409}
3410
3411muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3412: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3413{
3414 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3415 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3416}
3417
3419{
3420 if ((this->getModel()).isModelLinearized()) {
3421 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3422 } else {
3423 return myNPbase->muttHbb(sqrt_s);
3424 }
3425}
3426
3427muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3429{
3430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3431 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3432}
3433
3435{
3436 //VM:Note that these values are valid for 13 TeV, they are not general
3437 //We should access the SM function that has all the values (for the
3438 //different energies). The values are slightly different, we should
3439 //check this.
3440 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3441 double xsSM_ttH = 0.499873;
3442 double xsSM_tH = 0.0821;
3443 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3444 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3445 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3446 //AG: Most general expression including quadratic corrections.
3447 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3448 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3449 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3450 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3451 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3452
3453 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3454 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3455 double Br1 = dGammaR1-dGammaRTot1;
3456 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3457
3458 double mu;
3459
3460 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3461
3462 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3463
3464 return mu;
3465
3466 } else {
3467
3468
3469 //VM: Just in case someone wants to add directly the production*decay
3470 //(which is the observable we fit at the end)
3471 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3472 if(NPmuttHptH_Hbb==1.0){
3473 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3474 } else {
3475 return NPmuttHptH_Hbb;
3476 }
3477 }
3478}
3479
3480muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3481: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3482{
3483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3484 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3485}
3486
3488{
3489 //VM:Note that these values are valid for 13 TeV, they are not general
3490 //We should access the SM function that has all the values (for the
3491 //different energies). The values are slightly different, we should
3492 //check this. Furthermore, the bbH is not included. In the SM this is
3493 //very suppressed (and it's probably also the case in the SMEFT) but
3494 //in some NP models it may not be the case.Unfortunately, bbH is not
3495 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3496 //SMEFT and add here the general expression.
3497 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3498 double xsSM_ggHbbH = 44.745;
3499 double xsSM_VBF = 3.49948;
3500 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3501 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3502 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3503 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3504 //AG: Most general expression including quadratic corrections.
3505 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3506 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3507 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3508 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3509 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3510
3511 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3512 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3513 double Br1 = dGammaR1-dGammaRTot1;
3514 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3515
3516 double mu;
3517
3518 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3519
3520 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3521
3522 return mu;
3523
3524 } else {
3525
3526
3527 //VM: Just in case someone wants to add directly the production*decay
3528 //(which is the observable we fit at the end). Furthermore, the Hbb
3529 //is not added in the original formula, fine for the SM (probably also
3530 //for the SMEFT) but not for all NP models.
3531 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3532 if(NPmuggHpVBFpbbH_Hbb==1.0){
3533 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3534 } else {
3535 return NPmuggHpVBFpbbH_Hbb;
3536 }
3537 }
3538}
3539
3540
3541
3542muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3543: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3544{
3545 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3546 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3547}
3548
3550{
3551 if ((this->getModel()).isModelLinearized()) {
3552 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3553 } else {
3554 return myNPbase->muVHcc(sqrt_s);
3555 }
3556}
3557
3558
3559muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3560: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3561{
3562 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3563 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3564}
3565
3567{
3568
3569 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3570
3571}
3572
3573muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3574: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3575{
3576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3577 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3578}
3579
3581{
3582
3583 if ((this->getModel()).isModelLinearized()) {
3584 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3585 } else {
3586 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3587 }
3588
3589}
3590
3591
3592muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3593: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3594{
3595 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3596 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3597}
3598
3600{
3601
3602 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3603
3604}
3605
3606muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3608{
3609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3610 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3611}
3612
3614{
3615
3616 if ((this->getModel()).isModelLinearized()) {
3617 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3618 } else {
3619 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3620 }
3621
3622}
3623
3624
3625muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3627{
3628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3629 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3630}
3631
3633{
3634 return myNPbase->muppHmumu(sqrt_s);
3635}
3636
3637muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3638: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3639{
3640 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3641 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3642}
3643
3645{
3646 return myNPbase->muppHZga(sqrt_s);
3647}
3648
3649muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3650: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3651{
3652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3653 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3654}
3655
3657{
3658 if ((this->getModel()).isModelLinearized()) {
3659 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3660 } else {
3662 }
3663}
3664
3665muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3667{
3668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3669 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3670}
3671
3673{
3674 return (myNPbase->muttHZbbboost(sqrt_s));
3675}
3676
3677muttHgagaZeeboost::muttHgagaZeeboost(const StandardModel& SM_i, const double sqrt_s_i)
3678: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3679{
3680 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3681 throw std::runtime_error("muttHgagaZeeboost called with a class whose parent is not NPbase");
3682}
3683
3685{
3687}
3688
3689//AG:begin
3690ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3692{
3693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3694 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3695}
3697{
3698 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3699 if ((this->getModel()).isModelLinearized()) {
3700 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3701 } else {
3702 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3703 }
3704}
3705
3706
3707ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3709{
3710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3711 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3712}
3714{
3715 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3716 if ((this->getModel()).isModelLinearized()) {
3717 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3718 } else {
3719 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3720 }
3721}
3722
3723
3724ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3725: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3726{
3727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3728 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3729}
3731{
3732 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3733 if ((this->getModel()).isModelLinearized()) {
3734 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3735 } else {
3736 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3737 }
3738}
3739
3740
3741ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3743{
3744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3745 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3746}
3748{
3749 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3750 if ((this->getModel()).isModelLinearized()) {
3751 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3752 } else {
3753 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3754 }
3755}
3756
3757
3758VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3759: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3760{
3761 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3762 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3763}
3765{
3766 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3767 if ((this->getModel()).isModelLinearized()) {
3768 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3769 } else {
3770 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3771 }
3772}
3773
3774
3775VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3777{
3778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3779 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3780}
3782{
3783 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3784 if ((this->getModel()).isModelLinearized()) {
3785 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3786 } else {
3787 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3788 }
3789}
3790
3791
3792VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3793: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3794{
3795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3796 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3797}
3799{
3800 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3801 if ((this->getModel()).isModelLinearized()) {
3802 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3803 } else {
3804 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3805 }
3806}
3807
3808
3809VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3810: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3811{
3812 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3813 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3814}
3816{
3817 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3818 if ((this->getModel()).isModelLinearized()) {
3819 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3820 } else {
3821 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3822 }
3823}
3824
3825
3826WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3827: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3828{
3829 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3830 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3831}
3833{
3834 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3835 if ((this->getModel()).isModelLinearized()) {
3836 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3837 } else {
3838 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3839 }
3840}
3841
3842
3843WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3845{
3846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3847 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3848}
3850{
3851 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3852 if ((this->getModel()).isModelLinearized()) {
3853 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3854 } else {
3855 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3856 }
3857}
3858
3859
3860WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3862{
3863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3864 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3865}
3867{
3868 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3869 if ((this->getModel()).isModelLinearized()) {
3870 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3871 } else {
3872 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3873 }
3874}
3875
3876
3877WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3878: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3879{
3880 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3881 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3882}
3884{
3885 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3886 if ((this->getModel()).isModelLinearized()) {
3887 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3888 } else {
3889 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3890 }
3891}
3892
3893
3894ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3895: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3896{
3897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3898 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3899}
3901{
3902 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3903 if ((this->getModel()).isModelLinearized()) {
3904 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3905 } else {
3906 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3907 }
3908}
3909
3910
3911ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3912: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3913{
3914 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3915 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3916}
3918{
3919 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3920 if ((this->getModel()).isModelLinearized()) {
3921 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3922 } else {
3923 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3924 }
3925}
3926
3927
3928ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3929: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3930{
3931 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3932 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3933}
3935{
3936 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3937 if ((this->getModel()).isModelLinearized()) {
3938 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3939 } else {
3940 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3941 }
3942}
3943
3944
3945ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3946: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3947{
3948 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3949 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3950}
3952{
3953 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3954 if ((this->getModel()).isModelLinearized()) {
3955 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3956 } else {
3957 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3958 }
3959}
3960
3961
3962ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3963: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3964{
3965 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3966 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3967}
3969{
3970 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3971 if ((this->getModel()).isModelLinearized()) {
3972 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3973 } else {
3974 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3975 }
3976}
3977
3978
3979ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3980: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3981{
3982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3983 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3984}
3986{
3987 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3988 if ((this->getModel()).isModelLinearized()) {
3989 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3990 } else {
3991 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3992 }
3993}
3994
3995
3996ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3997: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3998{
3999 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4000 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
4001}
4003{
4004 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4005 if ((this->getModel()).isModelLinearized()) {
4006 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4007 } else {
4008 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
4009 }
4010}
4011
4012
4013ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
4014: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4015{
4016 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4017 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
4018}
4020{
4021 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4022 if ((this->getModel()).isModelLinearized()) {
4023 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4024 } else {
4025 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
4026 }
4027}
4028
4029//AG:end
4030
4031UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4032{
4033 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4034 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4035}
4036
4038{
4040}
4041
4042UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4043{
4044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4045 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4046}
4047
4049{
4051}
4052
4053UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4054{
4055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4056 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4057}
4058
4060{
4062}
4063
4064UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4065{
4066 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4067 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4068}
4069
4071{
4073}
4074
4076{
4077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4078 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4079}
4080
4082{
4083 return myNPbase->cgplusct();
4084}
4085
4087{
4088 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4089 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4090}
4091
4093{
4094 return myNPbase->cgaplusct();
4095}
4096
4098{
4099 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4100 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4101}
4102
4104{
4105 return myNPbase->cgminuscga();
4106}
4107
4109{
4110 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4111 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4112}
4113\
4114
4115
4117{
4118 return myNPbase->cVpluscb();
4119}
4120
4122{
4123 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4124 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4125}
4126
4128{
4129 return myNPbase->cVplusctau();
4130}
4131
4133{
4134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4135 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4136}
4137
4139{
4140 return myNPbase->cbminuscc();
4141}
4142
4144{
4145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4146 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4147}
4148
4150{
4151 return myNPbase->cbminusctau();
4152}
4153
4155{
4156 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4157 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4158}
4159
4161{
4162 return myNPbase->ccminusctau();
4163}
4164
4165
4166// Full signal strengths at e+ e- colliders
4167// ----------------------------------------
4168
4169mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4170: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4171{
4172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4173 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4174}
4175
4177{
4178 if ((this->getModel()).isModelLinearized()) {
4180 } else {
4182 }
4183}
4184
4185mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4186: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4187{
4188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4189 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4190}
4191
4193{
4194 if ((this->getModel()).isModelLinearized()) {
4196 } else {
4198 }
4199}
4200
4201mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4202: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4203{
4204 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4205 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4206}
4207
4209{
4210 if ((this->getModel()).isModelLinearized()) {
4212 } else {
4214 }
4215}
4216
4217mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4218: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4219{
4220 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4221 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4222}
4223
4225{
4226 if ((this->getModel()).isModelLinearized()) {
4228 } else {
4230 }
4231}
4232
4233mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4234: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4235{
4236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4237 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4238}
4239
4241{
4242 if ((this->getModel()).isModelLinearized()) {
4244 } else {
4246 }
4247}
4248
4249mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4250: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4251{
4252 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4253 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4254}
4255
4257{
4258 if ((this->getModel()).isModelLinearized()) {
4260 } else {
4262 }
4263}
4264
4265mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4266: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4267{
4268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4269 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4270}
4271
4273{
4274 if ((this->getModel()).isModelLinearized()) {
4276 } else {
4278 }
4279}
4280
4281mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4282: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4283{
4284 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4285 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4286}
4287
4289{
4290 if ((this->getModel()).isModelLinearized()) {
4292 } else {
4294 }
4295}
4296
4297mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4298: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4299{
4300 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4301 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4302}
4303
4305{
4306 if ((this->getModel()).isModelLinearized()) {
4308 } else {
4310 }
4311}
4312
4313mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4314: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4315{
4316 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4317 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4318}
4319
4321{
4322 if ((this->getModel()).isModelLinearized()) {
4324 } else {
4326 }
4327}
4328
4329mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4330: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4331{
4332 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4333 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4334}
4335
4337{
4338
4340
4341}
4342
4343mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4344: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4345{
4346 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4347 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4348}
4349
4351{
4352
4353 if ((this->getModel()).isModelLinearized()) {
4355 } else {
4357 }
4358
4359}
4360
4361mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4362: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4363{
4364 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4365 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4366
4367}
4368
4370{
4371 if ((this->getModel()).isModelLinearized()) {
4373 } else {
4374 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4375 }
4376}
4377
4378mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4379: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4380{
4381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4382 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4383
4384}
4385
4387{
4388 if ((this->getModel()).isModelLinearized()) {
4390 } else {
4392 }
4393}
4394
4395mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4397{
4398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4399 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4400
4401}
4402
4404{
4405 if ((this->getModel()).isModelLinearized()) {
4407 } else {
4408 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4409 }
4410}
4411
4412mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4413: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4414{
4415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4416 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4417
4418}
4419
4421{
4422 if ((this->getModel()).isModelLinearized()) {
4424 } else {
4425 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4426 }
4427}
4428
4429mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4430: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4431{
4432 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4433 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4434
4435}
4436
4438{
4439 if ((this->getModel()).isModelLinearized()) {
4441 } else {
4442 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4443 }
4444}
4445
4446mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4447: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4448{
4449 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4450 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4451
4452}
4453
4455{
4456 if ((this->getModel()).isModelLinearized()) {
4458 } else {
4460 }
4461}
4462
4463mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4464: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4465{
4466 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4467 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4468
4469}
4470
4472{
4473 if ((this->getModel()).isModelLinearized()) {
4475 } else {
4476 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4477 }
4478}
4479
4480mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4481: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4482{
4483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4484 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4485
4486}
4487
4489{
4490 if ((this->getModel()).isModelLinearized()) {
4492 } else {
4493 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4494 }
4495}
4496
4497mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4498: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4499{
4500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4501 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4502
4503}
4504
4506{
4507 if ((this->getModel()).isModelLinearized()) {
4509 } else {
4511 }
4512}
4513
4514mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4515: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4516{
4517 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4518 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4519
4520}
4521
4523{
4524 if ((this->getModel()).isModelLinearized()) {
4526 } else {
4528 }
4529}
4530
4531mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4532: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4533{
4534 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4535 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4536
4537}
4538
4540{
4541 if ((this->getModel()).isModelLinearized()) {
4543 } else {
4544 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4545 }
4546}
4547
4548mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4549: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4550{
4551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4552 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4553
4554}
4555
4557{
4558 if ((this->getModel()).isModelLinearized()) {
4560 } else {
4562 }
4563}
4564
4565mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4566: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4567{
4568 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4569 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4570
4571}
4572
4574{
4575 if ((this->getModel()).isModelLinearized()) {
4577 } else {
4578 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4579 }
4580}
4581
4582mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4583: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4584{
4585 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4586 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4587
4588}
4589
4591{
4592 if ((this->getModel()).isModelLinearized()) {
4594 } else {
4596 }
4597}
4598
4599
4600mueeHvvss::mueeHvvss(const StandardModel& SM_i, const double sqrt_s_i)
4601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4602{
4603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4604 throw std::runtime_error("mueeHvvss called with a class whose parent is not NPbase");
4605
4606}
4607
4609{
4610 if ((this->getModel()).isModelLinearized()) {
4612 } else {
4613 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHssRatio());
4614 }
4615}
4616
4617mueeHvvssPol::mueeHvvssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4618: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4619{
4620 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4621 throw std::runtime_error("mueeHvvssPol called with a class whose parent is not NPbase");
4622
4623}
4624
4626{
4627 if ((this->getModel()).isModelLinearized()) {
4629 } else {
4631 }
4632}
4633
4634
4635mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4637{
4638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4639 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4640
4641}
4642
4644{
4645 if ((this->getModel()).isModelLinearized()) {
4647 } else {
4648 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4649 }
4650}
4651
4652mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4653: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4654{
4655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4656 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4657
4658}
4659
4661{
4662 if ((this->getModel()).isModelLinearized()) {
4664 } else {
4666 }
4667}
4668
4669mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4670: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4671{
4672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4673 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4674
4675}
4676
4678{
4679 if ((this->getModel()).isModelLinearized()) {
4681 } else {
4682 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4683 }
4684}
4685
4686mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4687: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4688{
4689 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4690 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4691
4692}
4693
4695{
4696 if ((this->getModel()).isModelLinearized()) {
4698 } else {
4700 }
4701}
4702
4703mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4704: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4705{
4706 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4707 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4708
4709}
4710
4712{
4713 if ((this->getModel()).isModelLinearized()) {
4715 } else {
4717 }
4718}
4719
4720mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4721: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4722{
4723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4724 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4725
4726}
4727
4729{
4730 if ((this->getModel()).isModelLinearized()) {
4732 } else {
4734 }
4735}
4736
4737mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4738: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4739{
4740 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4741 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4742
4743}
4744
4746{
4747 if ((this->getModel()).isModelLinearized()) {
4749 } else {
4750 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4751 }
4752}
4753
4754mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4755: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4756{
4757 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4758 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4759
4760}
4761
4763{
4764 if ((this->getModel()).isModelLinearized()) {
4766 } else {
4768 }
4769}
4770
4771mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4772: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4773{
4774 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4775 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4776
4777}
4778
4780{
4781 if ((this->getModel()).isModelLinearized()) {
4783 } else {
4784 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4785 }
4786}
4787
4788mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4789: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4790{
4791 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4792 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4793
4794}
4795
4797{
4798 if ((this->getModel()).isModelLinearized()) {
4800 } else {
4802 }
4803}
4804
4805mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4806: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4807{
4808 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4809 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4810
4811}
4812
4814{
4815 if ((this->getModel()).isModelLinearized()) {
4817 } else {
4819 }
4820}
4821
4822mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4823: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4824{
4825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4826 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4827
4828}
4829
4831{
4832 if ((this->getModel()).isModelLinearized()) {
4834 } else {
4836 }
4837}
4838
4839mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4840: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4841{
4842 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4843 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4844
4845}
4846
4848{
4849 if ((this->getModel()).isModelLinearized()) {
4851 } else {
4853 }
4854}
4855
4856mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4857: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4858{
4859 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4860 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4861
4862}
4863
4865{
4866 if ((this->getModel()).isModelLinearized()) {
4868 } else {
4870 }
4871}
4872
4873mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4874: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4875{
4876 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4877 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4878}
4879
4881{
4882 if ((this->getModel()).isModelLinearized()) {
4884 } else {
4885 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4886 }
4887}
4888
4889mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4890: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4891{
4892 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4893 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4894}
4895
4897{
4898 if ((this->getModel()).isModelLinearized()) {
4900 } else {
4902 }
4903}
4904
4905mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4906: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4907{
4908 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4909 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4910}
4911
4913{
4914 if ((this->getModel()).isModelLinearized()) {
4916 } else {
4917 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4918 }
4919}
4920
4921mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4922: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4923{
4924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4925 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4926}
4927
4929{
4930 if ((this->getModel()).isModelLinearized()) {
4932 } else {
4934 }
4935}
4936
4937
4938// Production signal strengths at mu+ mu- colliders
4939// ------------------------------------------------
4940
4941mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4942: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4943{
4944 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4945 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4946}
4947
4949{
4950 return myNPbase->mummZH(sqrt_s);
4951}
4952
4953
4954mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4956{
4957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4958 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4959}
4960
4962{
4963 return myNPbase->mummHvv(sqrt_s);
4964}
4965
4966
4967mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
4968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4969{
4970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4971 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
4972}
4973
4975{
4976 return myNPbase->mummHmm(sqrt_s);
4977}
4978
4979
4980mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4981: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4982{
4983 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4984 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4985}
4986
4988{
4989 return myNPbase->mummttH(sqrt_s);
4990}
4991
4992
4993// Full signal strengths at mu+ mu- colliders
4994// -------------------------------------------
4995
4996
4997mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4998: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4999{
5000 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5001 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
5002}
5003
5005{
5006 if ((this->getModel()).isModelLinearized()) {
5007 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5008 } else {
5009 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
5010 }
5011}
5012
5013mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
5014: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5015{
5016 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5017 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5018}
5019
5021{
5022 if ((this->getModel()).isModelLinearized()) {
5023 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5024 } else {
5025 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5026 }
5027}
5028
5029mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5030: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5031{
5032 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5033 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5034}
5035
5037{
5038 if ((this->getModel()).isModelLinearized()) {
5039 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5040 } else {
5041 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5042 }
5043}
5044
5045mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5046: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5047{
5048 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5049 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5050}
5051
5053{
5054 if ((this->getModel()).isModelLinearized()) {
5055 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5056 } else {
5057 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5058 }
5059}
5060
5061mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5062: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5063{
5064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5065 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5066}
5067
5069{
5070 if ((this->getModel()).isModelLinearized()) {
5071 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5072 } else {
5074 }
5075}
5076
5077mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5078: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5079{
5080 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5081 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5082}
5083
5085{
5086 if ((this->getModel()).isModelLinearized()) {
5087 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5088 } else {
5089 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5090 }
5091}
5092
5093mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5094: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5095{
5096 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5097 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5098}
5099
5101{
5102 if ((this->getModel()).isModelLinearized()) {
5103 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5104 } else {
5105 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5106 }
5107}
5108
5109mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5110: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5111{
5112 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5113 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5114}
5115
5117{
5118 if ((this->getModel()).isModelLinearized()) {
5119 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5120 } else {
5121 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5122 }
5123}
5124
5125mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5126: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5127{
5128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5129 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5130}
5131
5133{
5134 if ((this->getModel()).isModelLinearized()) {
5135 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5136 } else {
5137 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5138 }
5139}
5140
5141
5142
5143mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5144: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5145{
5146 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5147 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5148}
5149
5151{
5152 if ((this->getModel()).isModelLinearized()) {
5153 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5154 } else {
5155 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5156 }
5157}
5158
5159mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5160: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5161{
5162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5163 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5164}
5165
5167{
5168 if ((this->getModel()).isModelLinearized()) {
5169 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5170 } else {
5171 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5172 }
5173}
5174
5175mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5176: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5177{
5178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5179 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5180}
5181
5183{
5184 if ((this->getModel()).isModelLinearized()) {
5185 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5186 } else {
5187 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5188 }
5189}
5190
5191mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5192: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5193{
5194 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5195 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5196}
5197
5199{
5200 if ((this->getModel()).isModelLinearized()) {
5201 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5202 } else {
5203 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5204 }
5205}
5206
5207mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5208: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5209{
5210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5211 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5212}
5213
5215{
5216 if ((this->getModel()).isModelLinearized()) {
5217 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5218 } else {
5220 }
5221}
5222
5223mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5225{
5226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5227 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5228}
5229
5231{
5232 if ((this->getModel()).isModelLinearized()) {
5233 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5234 } else {
5235 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5236 }
5237}
5238
5239mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5240: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5241{
5242 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5243 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5244}
5245
5247{
5248 if ((this->getModel()).isModelLinearized()) {
5249 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5250 } else {
5251 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5252 }
5253}
5254
5255mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5256: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5257{
5258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5259 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5260}
5261
5263{
5264 if ((this->getModel()).isModelLinearized()) {
5265 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5266 } else {
5267 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5268 }
5269}
5270
5271mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5272: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5273{
5274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5275 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5276}
5277
5279{
5280 if ((this->getModel()).isModelLinearized()) {
5281 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5282 } else {
5283 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5284 }
5285}
5286
5287
5288
5289mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5290: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5291{
5292 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5293 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5294}
5295
5297{
5298 if ((this->getModel()).isModelLinearized()) {
5299 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5300 } else {
5301 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5302 }
5303}
5304
5305mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5306: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5307{
5308 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5309 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5310}
5311
5313{
5314 if ((this->getModel()).isModelLinearized()) {
5315 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5316 } else {
5317 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5318 }
5319}
5320
5321mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5322: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5323{
5324 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5325 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5326}
5327
5329{
5330 if ((this->getModel()).isModelLinearized()) {
5331 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5332 } else {
5333 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5334 }
5335}
5336
5337mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5338: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5339{
5340 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5341 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5342}
5343
5345{
5346 if ((this->getModel()).isModelLinearized()) {
5347 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5348 } else {
5349 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5350 }
5351}
5352
5353mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5355{
5356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5357 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5358}
5359
5361{
5362 if ((this->getModel()).isModelLinearized()) {
5363 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5364 } else {
5366 }
5367}
5368
5369mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5370: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5371{
5372 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5373 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5374}
5375
5377{
5378 if ((this->getModel()).isModelLinearized()) {
5379 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5380 } else {
5381 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5382 }
5383}
5384
5385mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5386: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5387{
5388 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5389 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5390}
5391
5393{
5394 if ((this->getModel()).isModelLinearized()) {
5395 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5396 } else {
5397 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5398 }
5399}
5400
5401mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5402: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5403{
5404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5405 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5406}
5407
5409{
5410 if ((this->getModel()).isModelLinearized()) {
5411 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5412 } else {
5414 }
5415}
5416
5417mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5418: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5419{
5420 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5421 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5422}
5423
5425{
5426 if ((this->getModel()).isModelLinearized()) {
5427 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5428 } else {
5430 }
5431}
5432
5433
5434
5435mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5436: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5437{
5438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5439 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5440}
5441
5443{
5444 if ((this->getModel()).isModelLinearized()) {
5445 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5446 } else {
5447 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5448 }
5449}
5450
5451mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5452: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5453{
5454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5455 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5456}
5457
5459{
5460 if ((this->getModel()).isModelLinearized()) {
5461 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5462 } else {
5463 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5464 }
5465}
5466
5467mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5468: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5469{
5470 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5471 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5472}
5473
5475{
5476 if ((this->getModel()).isModelLinearized()) {
5477 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5478 } else {
5479 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5480 }
5481}
5482
5483mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5484: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5485{
5486 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5487 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5488}
5489
5491{
5492 if ((this->getModel()).isModelLinearized()) {
5493 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5494 } else {
5495 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5496 }
5497}
5498
5499mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5500: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5501{
5502 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5503 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5504}
5505
5507{
5508 if ((this->getModel()).isModelLinearized()) {
5509 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5510 } else {
5512 }
5513}
5514
5515mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5516: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5517{
5518 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5519 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5520}
5521
5523{
5524 if ((this->getModel()).isModelLinearized()) {
5525 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5526 } else {
5527 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5528 }
5529}
5530
5531mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5532: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5533{
5534 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5535 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5536}
5537
5539{
5540 if ((this->getModel()).isModelLinearized()) {
5541 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5542 } else {
5543 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5544 }
5545}
5546
5547mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5548: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5549{
5550 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5551 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5552}
5553
5555{
5556 if ((this->getModel()).isModelLinearized()) {
5557 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5558 } else {
5560 }
5561}
5562
5563mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5564: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5565{
5566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5567 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5568}
5569
5571{
5572 if ((this->getModel()).isModelLinearized()) {
5573 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5574 } else {
5576 }
5577}
5578
5579
5580mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5581: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5582{
5583 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5584 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5585}
5586
5588{
5589 if ((this->getModel()).isModelLinearized()) {
5590 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5591 } else {
5592 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5593 }
5594}
5595
5596mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5597: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5598{
5599 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5600 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5601}
5602
5604{
5605 if ((this->getModel()).isModelLinearized()) {
5606 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5607 } else {
5608 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5609 }
5610}
5611
5612mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5613: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5614{
5615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5616 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5617}
5618
5620{
5621 if ((this->getModel()).isModelLinearized()) {
5622 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5623 } else {
5624 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5625 }
5626}
5627
5628mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5629: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5630{
5631 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5632 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5633}
5634
5636{
5637 if ((this->getModel()).isModelLinearized()) {
5638 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5639 } else {
5640 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5641 }
5642}
5643
5644mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5646{
5647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5648 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5649}
5650
5652{
5653 if ((this->getModel()).isModelLinearized()) {
5654 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5655 } else {
5657 }
5658}
5659
5660mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5661: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5662{
5663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5664 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5665}
5666
5668{
5669 if ((this->getModel()).isModelLinearized()) {
5670 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5671 } else {
5672 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5673 }
5674}
5675
5676mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5677: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5678{
5679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5680 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5681}
5682
5684{
5685 if ((this->getModel()).isModelLinearized()) {
5686 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5687 } else {
5688 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5689 }
5690}
5691
5692mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5694{
5695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5696 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5697}
5698
5700{
5701 if ((this->getModel()).isModelLinearized()) {
5702 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5703 } else {
5705 }
5706}
5707
5708mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5710{
5711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5712 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5713}
5714
5716{
5717 if ((this->getModel()).isModelLinearized()) {
5718 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5719 } else {
5721 }
5722}
5723
5724
5725// The same in the narrow width approximation
5726
5727mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5728: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5729{
5730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5731 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5732}
5733
5735{
5736 if ((this->getModel()).isModelLinearized()) {
5737 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5738 } else {
5739 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5740 }
5741}
5742
5743mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5745{
5746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5747 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5748}
5749
5751{
5752 if ((this->getModel()).isModelLinearized()) {
5753 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5754 } else {
5755 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5756 }
5757}
5758
5759mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5760: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5761{
5762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5763 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5764}
5765
5767{
5768 if ((this->getModel()).isModelLinearized()) {
5769 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5770 } else {
5771 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5772 }
5773}
5774
5775mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5777{
5778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5779 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5780}
5781
5783{
5784 if ((this->getModel()).isModelLinearized()) {
5785 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5786 } else {
5787 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5788 }
5789}
5790
5791mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5792: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5793{
5794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5795 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5796}
5797
5799{
5800 if ((this->getModel()).isModelLinearized()) {
5801 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5802 } else {
5804 }
5805}
5806
5807mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5808: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5809{
5810 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5811 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5812}
5813
5815{
5816 if ((this->getModel()).isModelLinearized()) {
5817 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5818 } else {
5819 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5820 }
5821}
5822
5823mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5824: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5825{
5826 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5827 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5828}
5829
5831{
5832 if ((this->getModel()).isModelLinearized()) {
5833 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5834 } else {
5836 }
5837}
5838
5839mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5840: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5841{
5842 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5843 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5844}
5845
5847{
5848 if ((this->getModel()).isModelLinearized()) {
5849 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5850 } else {
5852 }
5853}
5854
5855mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5856: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5857{
5858 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5859 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5860}
5861
5863{
5864 if ((this->getModel()).isModelLinearized()) {
5865 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5866 } else {
5868 }
5869}
5870
5871// Full signal strengths at ep colliders
5872// -------------------------------------
5873
5874muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5875: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5876{
5877 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5878 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5879
5880}
5881
5883{
5884 if ((this->getModel()).isModelLinearized()) {
5885 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5886 } else {
5887 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5888 }
5889}
5890
5891muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5892: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5893{
5894 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5895 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5896
5897}
5898
5900{
5901 if ((this->getModel()).isModelLinearized()) {
5902 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5903 } else {
5904 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5905 }
5906}
5907
5908muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5909: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5910{
5911 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5912 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5913
5914}
5915
5917{
5918 if ((this->getModel()).isModelLinearized()) {
5919 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5920 } else {
5921 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5922 }
5923}
5924
5925muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5926: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5927{
5928 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5929 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5930
5931}
5932
5934{
5935 if ((this->getModel()).isModelLinearized()) {
5936 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5937 } else {
5939 }
5940}
5941
5942muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5943: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5944{
5945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5946 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5947
5948}
5949
5951{
5952 if ((this->getModel()).isModelLinearized()) {
5953 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5954 } else {
5955 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5956 }
5957}
5958
5959muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5960: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5961{
5962 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5963 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5964
5965}
5966
5968{
5969 if ((this->getModel()).isModelLinearized()) {
5970 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5971 } else {
5973 }
5974}
5975
5976muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5977: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5978{
5979 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5980 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5981
5982}
5983
5985{
5986 if ((this->getModel()).isModelLinearized()) {
5987 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5988 } else {
5990 }
5991}
5992
5993muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5994: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5995{
5996 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5997 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5998
5999}
6000
6002{
6003 if ((this->getModel()).isModelLinearized()) {
6004 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6005 } else {
6006 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
6007 }
6008}
6009
6010muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6011: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6012{
6013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6014 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
6015
6016}
6017
6019{
6020 if ((this->getModel()).isModelLinearized()) {
6021 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6022 } else {
6023 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6024 }
6025}
6026
6027muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6028: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6029{
6030 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6031 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6032
6033}
6034
6036{
6037 if ((this->getModel()).isModelLinearized()) {
6038 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6039 } else {
6040 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6041 }
6042}
6043
6044muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6045: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6046{
6047 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6048 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6049
6050}
6051
6053{
6054 if ((this->getModel()).isModelLinearized()) {
6055 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6056 } else {
6058 }
6059}
6060
6061muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6062: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6063{
6064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6065 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6066
6067}
6068
6070{
6071 if ((this->getModel()).isModelLinearized()) {
6072 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6073 } else {
6074 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6075 }
6076}
6077
6078muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6079: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6080{
6081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6082 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6083
6084}
6085
6087{
6088 if ((this->getModel()).isModelLinearized()) {
6089 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6090 } else {
6092 }
6093}
6094
6095muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6096: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6097{
6098 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6099 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6100
6101}
6102
6104{
6105 if ((this->getModel()).isModelLinearized()) {
6106 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6107 } else {
6109 }
6110}
6111
6112
6113// -----------------------------------------------------------------------------
6114// STXS bins
6115// -----------------------------------------------------------------------------
6116
6117// -----------------------------------------------------------------------------
6118// Stage 0
6119// -----------------------------------------------------------------------------
6120
6121STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6122: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6123{
6124 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6125 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6126
6127}
6128
6130{
6131 return myNPbase->STXS0_qqH(sqrt_s);
6132}
6133
6134
6135// -----------------------------------------------------------------------------
6136// Stage 1
6137// -----------------------------------------------------------------------------
6138
6140: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6141{
6142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6143 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6144
6145}
6146
6148{
6149 if ((this->getModel()).isModelLinearized()) {
6150 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6151 } else {
6153 }
6154}
6155
6156
6158: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6159{
6160 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6161 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6162
6163}
6164
6166{
6167 if ((this->getModel()).isModelLinearized()) {
6168 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6169 } else {
6171 }
6172}
6173
6174
6175STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6176: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6177{
6178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6179 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6180
6181}
6182
6184{
6185 if ((this->getModel()).isModelLinearized()) {
6186 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6187 } else {
6189 }
6190}
6191
6193: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6194{
6195 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6196 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6197
6198}
6199
6201{
6202 if ((this->getModel()).isModelLinearized()) {
6203 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6204 } else {
6206 }
6207}
6208
6210: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6211{
6212 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6213 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6214
6215}
6216
6218{
6219 if ((this->getModel()).isModelLinearized()) {
6220 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6221 } else {
6223 }
6224}
6225
6227: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6228{
6229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6230 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6231
6232}
6233
6235{
6236 if ((this->getModel()).isModelLinearized()) {
6237 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6238 } else {
6240 }
6241}
6242
6244: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6245{
6246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6247 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6248
6249}
6250
6252{
6253 if ((this->getModel()).isModelLinearized()) {
6254 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6255 } else {
6257 }
6258}
6259
6261: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6262{
6263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6264 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6265
6266}
6267
6269{
6270 if ((this->getModel()).isModelLinearized()) {
6271 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6272 } else {
6274 }
6275}
6276
6277
6279: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6280{
6281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6282 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6283
6284}
6285
6287{
6288 if ((this->getModel()).isModelLinearized()) {
6289 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6290 } else {
6292 }
6293}
6294
6295
6297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6298{
6299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6300 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6301
6302}
6303
6305{
6306 if ((this->getModel()).isModelLinearized()) {
6307 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6308 } else {
6310 }
6311}
6312
6313
6315: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6316{
6317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6318 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6319
6320}
6321
6323{
6324 if ((this->getModel()).isModelLinearized()) {
6325 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6326 } else {
6328 }
6329}
6330
6331
6333: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6334{
6335 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6336 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6337
6338}
6339
6341{
6342 if ((this->getModel()).isModelLinearized()) {
6343 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6344 } else {
6346 }
6347}
6348
6349
6351: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6352{
6353 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6354 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6355
6356}
6357
6359{
6360 if ((this->getModel()).isModelLinearized()) {
6361 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6362 } else {
6364 }
6365}
6366
6367
6369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6370{
6371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6372 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6373
6374}
6375
6377{
6378 if ((this->getModel()).isModelLinearized()) {
6379 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6380 } else {
6382 }
6383}
6384
6385
6386
6388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6389{
6390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6391 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6392
6393}
6394
6396{
6397 if ((this->getModel()).isModelLinearized()) {
6398 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6399 } else {
6401 }
6402}
6403
6404
6405
6407: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6408{
6409 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6410 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6411
6412}
6413
6415{
6416 if ((this->getModel()).isModelLinearized()) {
6417 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6418 } else {
6420 }
6421}
6422
6423
6424
6426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6427{
6428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6429 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6430
6431}
6432
6434{
6435 if ((this->getModel()).isModelLinearized()) {
6436 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6437 } else {
6439 }
6440}
6441
6442
6443STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6444: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6445{
6446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6447 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6448
6449}
6450
6452{
6453 if ((this->getModel()).isModelLinearized()) {
6454 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6455 } else {
6457 }
6458}
6459
6460
6462: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6463{
6464 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6465 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6466
6467}
6468
6470{
6471 if ((this->getModel()).isModelLinearized()) {
6472 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6473 } else {
6475 }
6476}
6477
6479: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6480{
6481 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6482 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6483
6484}
6485
6487{
6488 if ((this->getModel()).isModelLinearized()) {
6489 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6490 } else {
6492 }
6493}
6494
6495
6497: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6498{
6499 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6500 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6501
6502}
6503
6505{
6506 if ((this->getModel()).isModelLinearized()) {
6507 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6508 } else {
6510 }
6511}
6512
6513
6514
6516: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6517{
6518 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6519 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6520
6521}
6522
6524{
6525 if ((this->getModel()).isModelLinearized()) {
6527 } else {
6529 }
6530}
6531
6532
6533
6535: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6536{
6537 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6538 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6539
6540}
6541
6543{
6544 if ((this->getModel()).isModelLinearized()) {
6546 } else {
6548 }
6549}
6550
6551
6553: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6554{
6555 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6556 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6557
6558}
6559
6561{
6562 if ((this->getModel()).isModelLinearized()) {
6563 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6564 } else {
6566 }
6567}
6568
6570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6571{
6572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6573 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6574
6575}
6576
6578{
6579 if ((this->getModel()).isModelLinearized()) {
6580 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6581 } else {
6583 }
6584}
6585
6587: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6588{
6589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6590 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6591
6592}
6593
6595{
6596 if ((this->getModel()).isModelLinearized()) {
6597 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6598 } else {
6600 }
6601}
6602
6603
6605: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6606{
6607 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6608 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6609
6610}
6611
6613{
6614 if ((this->getModel()).isModelLinearized()) {
6616 } else {
6618 }
6619}
6620
6621
6623: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6624{
6625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6626 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6627
6628}
6629
6631{
6632 if ((this->getModel()).isModelLinearized()) {
6634 } else {
6636 }
6637}
6638
6639
6641: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6642{
6643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6644 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6645
6646}
6647
6649{
6650 if ((this->getModel()).isModelLinearized()) {
6651 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6652 } else {
6654 }
6655}
6656
6657STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6658: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6659{
6660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6661 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6662
6663}
6664
6666{
6667 if ((this->getModel()).isModelLinearized()) {
6668 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6669 } else {
6671 }
6672}
6673
6674
6676: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6677{
6678 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6679 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6680
6681}
6682
6684{
6685 if ((this->getModel()).isModelLinearized()) {
6686 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6687 } else {
6689 }
6690}
6691
6692
6694: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6695{
6696 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6697 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6698
6699}
6700
6702{
6703 if ((this->getModel()).isModelLinearized()) {
6704 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6705 } else {
6707 }
6708}
6709
6710
6711
6713: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6714{
6715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6716 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6717
6718}
6719
6721{
6722 if ((this->getModel()).isModelLinearized()) {
6724 } else {
6726 }
6727}
6728
6729
6730
6732: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6733{
6734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6735 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6736
6737}
6738
6740{
6741 if ((this->getModel()).isModelLinearized()) {
6743 } else {
6745 }
6746}
6747
6748
6750: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6751{
6752 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6753 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6754
6755}
6756
6758{
6759 if ((this->getModel()).isModelLinearized()) {
6760 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6761 } else {
6763 }
6764}
6765
6767: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6768{
6769 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6770 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6771
6772}
6773
6775{
6776 if ((this->getModel()).isModelLinearized()) {
6777 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6778 } else {
6780 }
6781}
6782
6784: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6785{
6786 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6787 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6788
6789}
6790
6792{
6793 if ((this->getModel()).isModelLinearized()) {
6794 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6795 } else {
6797 }
6798}
6799
6800
6802: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6803{
6804 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6805 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6806
6807}
6808
6810{
6811 if ((this->getModel()).isModelLinearized()) {
6813 } else {
6815 }
6816}
6817
6818
6820: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6821{
6822 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6823 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6824
6825}
6826
6828{
6829 if ((this->getModel()).isModelLinearized()) {
6831 } else {
6833 }
6834}
6835
6836
6838: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6839{
6840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6841 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6842
6843}
6844
6846{
6847 if ((this->getModel()).isModelLinearized()) {
6848 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6849 } else {
6851 }
6852}
6853
6854
6856: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6857{
6858 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6859 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6860
6861}
6862
6864{
6865 if ((this->getModel()).isModelLinearized()) {
6867 } else {
6869 }
6870}
6871
6872
6874: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6875{
6876 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6877 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6878
6879}
6880
6882{
6883 if ((this->getModel()).isModelLinearized()) {
6884 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6885 } else {
6887 }
6888}
6889
6890
6892: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6893{
6894 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6895 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6896
6897}
6898
6900{
6901 if ((this->getModel()).isModelLinearized()) {
6902 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6903 } else {
6905 }
6906}
6907
6908
6910: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6911{
6912 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6913 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6914
6915}
6916
6918{
6919 if ((this->getModel()).isModelLinearized()) {
6920 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6921 } else {
6923 }
6924}
6925
6926
6928: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6929{
6930 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6931 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6932
6933}
6934
6936{
6937 if ((this->getModel()).isModelLinearized()) {
6938 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6939 } else {
6941 }
6942}
6943
6944
6946: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6947{
6948 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6949 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6950
6951}
6952
6954{
6955 if ((this->getModel()).isModelLinearized()) {
6957 } else {
6959 }
6960}
6961
6962
6964: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6965{
6966 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6967 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6968
6969}
6970
6972{
6973 if ((this->getModel()).isModelLinearized()) {
6974 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6975 } else {
6977 }
6978}
6979
6980
6982: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6983{
6984 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6985 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6986
6987}
6988
6990{
6991 if ((this->getModel()).isModelLinearized()) {
6992 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6993 } else {
6995 }
6996}
6997
6998
7000: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7001{
7002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7003 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7004
7005}
7006
7008{
7009 if ((this->getModel()).isModelLinearized()) {
7010 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7011 } else {
7013 }
7014}
7015
7016
7018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7019{
7020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7021 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7022
7023}
7024
7026{
7027 if ((this->getModel()).isModelLinearized()) {
7028 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7029 } else {
7031 }
7032}
7033
7034
7035
7036// -----------------------------------------------------------------------------
7037// Stage 1.2
7038// -----------------------------------------------------------------------------
7039
7040STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7041: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7042{
7043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7044 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7045
7046}
7047
7049{
7050 double BrHXXRatio = 1.0;
7051 if (fstate == 1){
7052 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7053 } else if (fstate == 2){
7054 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7055 } else if (fstate == 3){
7056 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7057 } else if (fstate == 4){
7058 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7059 } else {
7060 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7061 }
7062
7063 if ((this->getModel()).isModelLinearized()) {
7064 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7065 } else {
7066 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7067 }
7068}
7069
7070// -----------------------------------------------------------------------------
7071
7072STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7073: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7074{
7075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7076 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7077
7078}
7079
7081{
7082 double BrHXXRatio = 1.0;
7083 if (fstate == 1){
7084 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7085 } else if (fstate == 2){
7086 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7087 } else if (fstate == 3){
7088 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7089 } else if (fstate == 4){
7090 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7091 } else {
7092 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7093 }
7094
7095 if ((this->getModel()).isModelLinearized()) {
7096 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7097 } else {
7098 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7099 }
7100}
7101
7102// -----------------------------------------------------------------------------
7103
7104STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7105: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7106{
7107 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7108 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7109
7110}
7111
7113{
7114 double BrHXXRatio = 1.0;
7115 if (fstate == 1){
7116 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7117 } else if (fstate == 2){
7118 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7119 } else if (fstate == 3){
7120 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7121 } else if (fstate == 4){
7122 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7123 } else {
7124 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7125 }
7126
7127 if ((this->getModel()).isModelLinearized()) {
7128 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7129 } else {
7130 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7131 }
7132}
7133
7134// -----------------------------------------------------------------------------
7135
7136STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7137: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7138{
7139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7140 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7141
7142}
7143
7145{
7146 double BrHXXRatio = 1.0;
7147 if (fstate == 1){
7148 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7149 } else if (fstate == 2){
7150 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7151 } else if (fstate == 3){
7152 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7153 } else if (fstate == 4){
7154 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7155 } else {
7156 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7157 }
7158
7159 if ((this->getModel()).isModelLinearized()) {
7160 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7161 } else {
7162 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7163 }
7164}
7165
7166
7167// -----------------------------------------------------------------------------
7168
7169STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7170: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7171{
7172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7173 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7174
7175}
7176
7178{
7179 //-- Production:
7180 double weight = 1.0; //If normalized to the SM
7181
7182 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7183 double muProd1 = muProd -1.0;
7184 double muProd2 = 0.0;
7185 //-- Decay:
7186 double BrHXXRatio = 1.0;
7187 double dBrHXXRatio1 = 0.0;
7188 double dBrHXXRatio2 = 0.0;
7189
7190 if (fstate == 1){
7191 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7192 dBrHXXRatio1 = BrHXXRatio - 1.0;
7193 dBrHXXRatio2 = 0.0;
7194 } else if (fstate == 2){
7195 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7196 dBrHXXRatio1 = BrHXXRatio - 1.0;
7197 dBrHXXRatio2 = 0.0;
7198 } else if (fstate == 3){
7199 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7200 dBrHXXRatio1 = BrHXXRatio - 1.0;
7201 dBrHXXRatio2 = 0.0;
7202 } else if (fstate == 4){
7203 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7204 dBrHXXRatio1 = BrHXXRatio - 1.0;
7205 dBrHXXRatio2 = 0.0;
7206 } else {
7207 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7208 }
7209
7210 //-- Production x Decay:
7211 if ((this->getModel()).isModelLinearized()){
7212 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7213 } else if((this->getModel()).isModelNPquadratic()){
7214 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7215 } else {
7216 return weight*(muProd)*(BrHXXRatio);
7217 }
7218}
7219
7220
7221
7222
7223
7224// -----------------------------------------------------------------------------
7225
7226//VM:STXS2024;
7227STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7228: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7229{
7230 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7231 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7232
7233}
7234
7236{
7237 //-- Production:
7238 double weight = 1.0; //If normalized to the SM
7239 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7240 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7241 double muProd1 = muProd -1.0;
7242 double muProd2 = 0.0;
7243
7244 //-- Decay:
7245 double BrHXXRatio = 1.0;
7246 double dBrHXXRatio1 = 0.0;
7247 double dBrHXXRatio2 = 0.0;
7248 if (fstate==0){
7249 // Use for Cross-section [pb] with no Higgs-boson decay
7250 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7251 } else if (fstate == 1){
7252 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7253 dBrHXXRatio1 = BrHXXRatio - 1.0;
7254 dBrHXXRatio2 = 0.0;
7255 } else if (fstate == 2){
7256 BrHXXRatio = (myNPbase->BrHgagaRatio());
7257 dBrHXXRatio1 = BrHXXRatio - 1.0;
7258 dBrHXXRatio2 = 0.0;
7259 } else if (fstate == 3){
7260 BrHXXRatio = (myNPbase->BrHbbRatio());
7261 dBrHXXRatio1 = BrHXXRatio - 1.0;
7262 dBrHXXRatio2 = 0.0;
7263 } else if (fstate == 4){
7264 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7265 dBrHXXRatio1 = BrHXXRatio - 1.0;
7266 dBrHXXRatio2 = 0.0;
7267 } else if (fstate == 5){
7268 BrHXXRatio = (myNPbase->BrHtautauRatio());
7269 dBrHXXRatio1 = BrHXXRatio - 1.0;
7270 dBrHXXRatio2 = 0.0;
7271 } else if (fstate == 6){
7272 BrHXXRatio = (myNPbase->BrHWWRatio());
7273 dBrHXXRatio1 = BrHXXRatio - 1.0;
7274 dBrHXXRatio2 = 0.0;
7275 } else if (fstate == 7){
7276 BrHXXRatio = (myNPbase->BrHZZRatio());
7277 dBrHXXRatio1 = BrHXXRatio - 1.0;
7278 dBrHXXRatio2 = 0.0;
7279 } else {
7280 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7281 }
7282
7283 //-- Production x Decay:
7284 if ((this->getModel()).isModelLinearized()){
7285 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7286 } else if((this->getModel()).isModelNPquadratic()){
7287 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7288 } else {
7289 return weight*(muProd)*(BrHXXRatio);
7290 }
7291
7292}
7293
7294
7295
7296// -----------------------------------------------------------------------------
7297
7298//VM:STXS2024;
7299STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7300: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7301{
7302 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7303 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7304
7305}
7306
7308{
7309 //-- Production:
7310 double weight = 1.0; //If normalized to the SM
7311 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7312 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7313 double muProd1 = muProd -1.0;
7314 double muProd2 = 0.0;
7315
7316 //-- Decay:
7317 double BrHXXRatio = 1.0;
7318 double dBrHXXRatio1 = 0.0;
7319 double dBrHXXRatio2 = 0.0;
7320 if (fstate==0){
7321 // Use for Cross-section [pb] with no Higgs-boson decay
7322 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7323 } else if (fstate == 1){
7324 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7326 dBrHXXRatio2 = 0.0;
7327 } else if (fstate == 2){
7328 BrHXXRatio = (myNPbase->BrHgagaRatio());
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7330 dBrHXXRatio2 = 0.0;
7331 } else if (fstate == 3){
7332 BrHXXRatio = (myNPbase->BrHbbRatio());
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7334 dBrHXXRatio2 = 0.0;
7335 } else if (fstate == 4){
7336 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7337 dBrHXXRatio1 = BrHXXRatio - 1.0;
7338 dBrHXXRatio2 = 0.0;
7339 } else if (fstate == 5){
7340 BrHXXRatio = (myNPbase->BrHtautauRatio());
7341 dBrHXXRatio1 = BrHXXRatio - 1.0;
7342 dBrHXXRatio2 = 0.0;
7343 } else if (fstate == 6){
7344 BrHXXRatio = (myNPbase->BrHWWRatio());
7345 dBrHXXRatio1 = BrHXXRatio - 1.0;
7346 dBrHXXRatio2 = 0.0;
7347 } else if (fstate == 7){
7348 BrHXXRatio = (myNPbase->BrHZZRatio());
7349 dBrHXXRatio1 = BrHXXRatio - 1.0;
7350 dBrHXXRatio2 = 0.0;
7351 } else {
7352 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7353 }
7354
7355 //-- Production x Decay:
7356 if ((this->getModel()).isModelLinearized()){
7357 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7358 } else if((this->getModel()).isModelNPquadratic()){
7359 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7360 } else {
7361 return weight*(muProd)*(BrHXXRatio);
7362 }
7363
7364}
7365
7366
7367
7368
7369// -----------------------------------------------------------------------------
7370
7371//VM:STXS2024;
7372STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7373: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7374{
7375 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7376 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7377
7378}
7379
7381{
7382 //-- Production:
7383 double weight = 1.0; //If normalized to the SM
7384 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7385 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7387 /(6.6369 + 20.642);
7388 double muProd1 = muProd -1.0;
7389 double muProd2 = 0.0;
7390
7391 //-- Decay:
7392 double BrHXXRatio = 1.0;
7393 double dBrHXXRatio1 = 0.0;
7394 double dBrHXXRatio2 = 0.0;
7395 if (fstate==0){
7396 // Use for Cross-section [pb] with no Higgs-boson decay
7397 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7398 } else if (fstate == 1){
7399 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7400 dBrHXXRatio1 = BrHXXRatio - 1.0;
7401 dBrHXXRatio2 = 0.0;
7402 } else if (fstate == 2){
7403 BrHXXRatio = (myNPbase->BrHgagaRatio());
7404 dBrHXXRatio1 = BrHXXRatio - 1.0;
7405 dBrHXXRatio2 = 0.0;
7406 } else if (fstate == 3){
7407 BrHXXRatio = (myNPbase->BrHbbRatio());
7408 dBrHXXRatio1 = BrHXXRatio - 1.0;
7409 dBrHXXRatio2 = 0.0;
7410 } else if (fstate == 4){
7411 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7412 dBrHXXRatio1 = BrHXXRatio - 1.0;
7413 dBrHXXRatio2 = 0.0;
7414 } else if (fstate == 5){
7415 BrHXXRatio = (myNPbase->BrHtautauRatio());
7416 dBrHXXRatio1 = BrHXXRatio - 1.0;
7417 dBrHXXRatio2 = 0.0;
7418 } else if (fstate == 6){
7419 BrHXXRatio = (myNPbase->BrHWWRatio());
7420 dBrHXXRatio1 = BrHXXRatio - 1.0;
7421 dBrHXXRatio2 = 0.0;
7422 } else if (fstate == 7){
7423 BrHXXRatio = (myNPbase->BrHZZRatio());
7424 dBrHXXRatio1 = BrHXXRatio - 1.0;
7425 dBrHXXRatio2 = 0.0;
7426 } else {
7427 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7428 }
7429
7430 //-- Production x Decay:
7431 if ((this->getModel()).isModelLinearized()){
7432 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7433 } else if((this->getModel()).isModelNPquadratic()){
7434 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7435 } else {
7436 return weight*(muProd)*(BrHXXRatio);
7437 }
7438
7439}
7440
7441
7442
7443
7444// -----------------------------------------------------------------------------
7445
7446//VM:STXS2024;
7447STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7448: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7449{
7450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7451 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7452
7453}
7454
7456{
7457 //-- Production:
7458 double weight = 1.0; //If normalized to the SM
7459 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7460
7461 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7462 double muProd1 = muProd -1.0;
7463 double muProd2 = 0.0;
7464
7465 //-- Decay:
7466 double BrHXXRatio = 1.0;
7467 double dBrHXXRatio1 = 0.0;
7468 double dBrHXXRatio2 = 0.0;
7469 if (fstate==0){
7470 // Use for Cross-section [pb] with no Higgs-boson decay
7471 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7472 } else if (fstate == 1){
7473 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7475 dBrHXXRatio2 = 0.0;
7476 } else if (fstate == 2){
7477 BrHXXRatio = (myNPbase->BrHgagaRatio());
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7479 dBrHXXRatio2 = 0.0;
7480 } else if (fstate == 3){
7481 BrHXXRatio = (myNPbase->BrHbbRatio());
7482 dBrHXXRatio1 = BrHXXRatio - 1.0;
7483 dBrHXXRatio2 = 0.0;
7484 } else if (fstate == 4){
7485 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7486 dBrHXXRatio1 = BrHXXRatio - 1.0;
7487 dBrHXXRatio2 = 0.0;
7488 } else if (fstate == 5){
7489 BrHXXRatio = (myNPbase->BrHtautauRatio());
7490 dBrHXXRatio1 = BrHXXRatio - 1.0;
7491 dBrHXXRatio2 = 0.0;
7492 } else if (fstate == 6){
7493 BrHXXRatio = (myNPbase->BrHWWRatio());
7494 dBrHXXRatio1 = BrHXXRatio - 1.0;
7495 dBrHXXRatio2 = 0.0;
7496 } else if (fstate == 7){
7497 BrHXXRatio = (myNPbase->BrHZZRatio());
7498 dBrHXXRatio1 = BrHXXRatio - 1.0;
7499 dBrHXXRatio2 = 0.0;
7500 } else {
7501 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7502 }
7503
7504 //-- Production x Decay:
7505 if ((this->getModel()).isModelLinearized()){
7506 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7507 } else if((this->getModel()).isModelNPquadratic()){
7508 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7509 } else {
7510 return weight*(muProd)*(BrHXXRatio);
7511 }
7512
7513}
7514
7515
7516
7517
7518
7519
7520
7521// -----------------------------------------------------------------------------
7522
7523//AG:STXS2024
7524STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7525: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7526{
7527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7528 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7529
7530}
7531
7533{
7534 //-- Production:
7535 double weight = 1.0; //If normalized to the SM
7536 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7537 double muProd1 = muProd -1.0;
7538 double muProd2 = 0.0;
7539
7540 //-- Decay:
7541 double BrHXXRatio = 1.0;
7542 double dBrHXXRatio1 = 0.0;
7543 double dBrHXXRatio2 = 0.0;
7544 if (fstate==0){
7545 // Use for Cross-section [pb] with no Higgs-boson decay
7546 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7547 } else if (fstate == 1){
7548 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7550 dBrHXXRatio2 = 0.0;
7551 } else if (fstate == 2){
7552 BrHXXRatio = (myNPbase->BrHgagaRatio());
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7554 dBrHXXRatio2 = 0.0;
7555 } else if (fstate == 3){
7556 BrHXXRatio = (myNPbase->BrHbbRatio());
7557 dBrHXXRatio1 = BrHXXRatio - 1.0;
7558 dBrHXXRatio2 = 0.0;
7559 } else if (fstate == 4){
7560 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7561 dBrHXXRatio1 = BrHXXRatio - 1.0;
7562 dBrHXXRatio2 = 0.0;
7563 } else if (fstate == 5){
7564 BrHXXRatio = (myNPbase->BrHtautauRatio());
7565 dBrHXXRatio1 = BrHXXRatio - 1.0;
7566 dBrHXXRatio2 = 0.0;
7567 } else if (fstate == 6){
7568 BrHXXRatio = (myNPbase->BrHWWRatio());
7569 dBrHXXRatio1 = BrHXXRatio - 1.0;
7570 dBrHXXRatio2 = 0.0;
7571 } else if (fstate == 7){
7572 BrHXXRatio = (myNPbase->BrHZZRatio());
7573 dBrHXXRatio1 = BrHXXRatio - 1.0;
7574 dBrHXXRatio2 = 0.0;
7575 } else {
7576 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7577 }
7578
7579 //-- Production x Decay:
7580 if ((this->getModel()).isModelLinearized()){
7581 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7582 } else if((this->getModel()).isModelNPquadratic()){
7583 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7584 } else {
7585 return weight*(muProd)*(BrHXXRatio);
7586 }
7587
7588}
7589
7590// -----------------------------------------------------------------------------
7591
7592//AG:STXS2024
7593STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7594: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7595{
7596 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7597 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7598
7599}
7600
7602{
7603 //-- Production:
7604 double weight = 1.0; //If normalized to the SM
7605 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7606 double muProd1 = muProd -1.0;
7607 double muProd2 = 0.0;
7608
7609 //-- Decay:
7610 double BrHXXRatio = 1.0;
7611 double dBrHXXRatio1 = 0.0;
7612 double dBrHXXRatio2 = 0.0;
7613 if (fstate==0){
7614 // Use for Cross-section [pb] with no Higgs-boson decay
7615 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7616 } else if (fstate == 1){
7617 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7618 dBrHXXRatio1 = BrHXXRatio - 1.0;
7619 dBrHXXRatio2 = 0.0;
7620 } else if (fstate == 2){
7621 BrHXXRatio = (myNPbase->BrHgagaRatio());
7622 dBrHXXRatio1 = BrHXXRatio - 1.0;
7623 dBrHXXRatio2 = 0.0;
7624 } else if (fstate == 3){
7625 BrHXXRatio = (myNPbase->BrHbbRatio());
7626 dBrHXXRatio1 = BrHXXRatio - 1.0;
7627 dBrHXXRatio2 = 0.0;
7628 } else if (fstate == 4){
7629 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7630 dBrHXXRatio1 = BrHXXRatio - 1.0;
7631 dBrHXXRatio2 = 0.0;
7632 } else if (fstate == 5){
7633 BrHXXRatio = (myNPbase->BrHtautauRatio());
7634 dBrHXXRatio1 = BrHXXRatio - 1.0;
7635 dBrHXXRatio2 = 0.0;
7636 } else if (fstate == 6){
7637 BrHXXRatio = (myNPbase->BrHWWRatio());
7638 dBrHXXRatio1 = BrHXXRatio - 1.0;
7639 dBrHXXRatio2 = 0.0;
7640 } else if (fstate == 7){
7641 BrHXXRatio = (myNPbase->BrHZZRatio());
7642 dBrHXXRatio1 = BrHXXRatio - 1.0;
7643 dBrHXXRatio2 = 0.0;
7644 } else {
7645 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7646 }
7647
7648 //-- Production x Decay:
7649 if ((this->getModel()).isModelLinearized()){
7650 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7651 } else if((this->getModel()).isModelNPquadratic()){
7652 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7653 } else {
7654 return weight*(muProd)*(BrHXXRatio);
7655 }
7656
7657}
7658
7659// -----------------------------------------------------------------------------
7660
7661//AG:STXS2024
7662STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7663: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7664{
7665 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7666 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7667
7668}
7669
7671{
7672 //-- Production:
7673 double weight = 1.0; //If normalized to the SM
7674 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7675 double muProd1 = muProd -1.0;
7676 double muProd2 = 0.0;
7677
7678 //-- Decay:
7679 double BrHXXRatio = 1.0;
7680 double dBrHXXRatio1 = 0.0;
7681 double dBrHXXRatio2 = 0.0;
7682 if (fstate==0){
7683 // Use for Cross-section [pb] with no Higgs-boson decay
7684 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7685 } else if (fstate == 1){
7686 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7687 dBrHXXRatio1 = BrHXXRatio - 1.0;
7688 dBrHXXRatio2 = 0.0;
7689 } else if (fstate == 2){
7690 BrHXXRatio = (myNPbase->BrHgagaRatio());
7691 dBrHXXRatio1 = BrHXXRatio - 1.0;
7692 dBrHXXRatio2 = 0.0;
7693 } else if (fstate == 3){
7694 BrHXXRatio = (myNPbase->BrHbbRatio());
7695 dBrHXXRatio1 = BrHXXRatio - 1.0;
7696 dBrHXXRatio2 = 0.0;
7697 } else if (fstate == 4){
7698 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7699 dBrHXXRatio1 = BrHXXRatio - 1.0;
7700 dBrHXXRatio2 = 0.0;
7701 } else if (fstate == 5){
7702 BrHXXRatio = (myNPbase->BrHtautauRatio());
7703 dBrHXXRatio1 = BrHXXRatio - 1.0;
7704 dBrHXXRatio2 = 0.0;
7705 } else if (fstate == 6){
7706 BrHXXRatio = (myNPbase->BrHWWRatio());
7707 dBrHXXRatio1 = BrHXXRatio - 1.0;
7708 dBrHXXRatio2 = 0.0;
7709 } else if (fstate == 7){
7710 BrHXXRatio = (myNPbase->BrHZZRatio());
7711 dBrHXXRatio1 = BrHXXRatio - 1.0;
7712 dBrHXXRatio2 = 0.0;
7713 } else {
7714 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7715 }
7716
7717 //-- Production x Decay:
7718 if ((this->getModel()).isModelLinearized()){
7719 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7720 } else if((this->getModel()).isModelNPquadratic()){
7721 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7722 } else {
7723 return weight*(muProd)*(BrHXXRatio);
7724 }
7725
7726}
7727
7728// -----------------------------------------------------------------------------
7729
7730STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7731: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7732{
7733 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7734 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7735
7736}
7737
7739{
7740 double BrHXXRatio = 1.0;
7741 if (fstate == 1){
7742 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7743 } else if (fstate == 2){
7744 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7745 } else if (fstate == 3){
7746 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7747 } else if (fstate == 4){
7748 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7749 } else {
7750 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7751 }
7752
7753 if ((this->getModel()).isModelLinearized()) {
7754 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7755 } else {
7756 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7757 }
7758}
7759
7760// -----------------------------------------------------------------------------
7761
7762STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7763: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7764{
7765 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7766 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7767
7768}
7769
7771{
7772 double BrHXXRatio = 1.0;
7773 if (fstate == 1){
7774 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7775 } else if (fstate == 2){
7776 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7777 } else if (fstate == 3){
7778 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7779 } else if (fstate == 4){
7780 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7781 } else {
7782 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7783 }
7784
7785 if ((this->getModel()).isModelLinearized()) {
7786 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7787 } else {
7788 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7789 }
7790}
7791
7792
7793
7794
7795
7796// -----------------------------------------------------------------------------
7797
7798//VM:STXS2024;
7799STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7800: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7801{
7802 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7803 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7804
7805}
7806
7808{
7809 //-- Production:
7810 double weight = 1.0; //If normalized to the SM
7811 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7812 //We should weight each xsection with the SM prediction. We need to check
7813 //this values, nevertheless, the difference between the two parametrisations
7814 //is extremely small (way beyond our current precision)
7815 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7817 /(2.);
7818 double muProd1 = muProd -1.0;
7819 double muProd2 = 0.0;
7820
7821 //-- Decay:
7822 double BrHXXRatio = 1.0;
7823 double dBrHXXRatio1 = 0.0;
7824 double dBrHXXRatio2 = 0.0;
7825 if (fstate==0){
7826 // Use for Cross-section [pb] with no Higgs-boson decay
7827 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7828 } else if (fstate == 1){
7829 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7830 dBrHXXRatio1 = BrHXXRatio - 1.0;
7831 dBrHXXRatio2 = 0.0;
7832 } else if (fstate == 2){
7833 BrHXXRatio = (myNPbase->BrHgagaRatio());
7834 dBrHXXRatio1 = BrHXXRatio - 1.0;
7835 dBrHXXRatio2 = 0.0;
7836 } else if (fstate == 3){
7837 BrHXXRatio = (myNPbase->BrHbbRatio());
7838 dBrHXXRatio1 = BrHXXRatio - 1.0;
7839 dBrHXXRatio2 = 0.0;
7840 } else if (fstate == 4){
7841 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7842 dBrHXXRatio1 = BrHXXRatio - 1.0;
7843 dBrHXXRatio2 = 0.0;
7844 } else if (fstate == 5){
7845 BrHXXRatio = (myNPbase->BrHtautauRatio());
7846 dBrHXXRatio1 = BrHXXRatio - 1.0;
7847 dBrHXXRatio2 = 0.0;
7848 } else if (fstate == 6){
7849 BrHXXRatio = (myNPbase->BrHWWRatio());
7850 dBrHXXRatio1 = BrHXXRatio - 1.0;
7851 dBrHXXRatio2 = 0.0;
7852 } else if (fstate == 7){
7853 BrHXXRatio = (myNPbase->BrHZZRatio());
7854 dBrHXXRatio1 = BrHXXRatio - 1.0;
7855 dBrHXXRatio2 = 0.0;
7856 } else {
7857 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7858 }
7859
7860 //-- Production x Decay:
7861 if ((this->getModel()).isModelLinearized()){
7862 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7863 } else if((this->getModel()).isModelNPquadratic()){
7864 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7865 } else {
7866 return weight*(muProd)*(BrHXXRatio);
7867 }
7868
7869}
7870
7871
7872
7873
7874// -----------------------------------------------------------------------------
7875
7876//AG:STXS2024
7877STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7878: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7879{
7880 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7881 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7882
7883}
7884
7886{
7887 //-- Production:
7888 double weight = 1.0; //If normalized to the SM
7890 double muProd1 = muProd -1.0;
7891 double muProd2 = 0.0;
7892
7893 //-- Decay:
7894 double BrHXXRatio = 1.0;
7895 double dBrHXXRatio1 = 0.0;
7896 double dBrHXXRatio2 = 0.0;
7897 if (fstate==0){
7898 // Use for Cross-section [pb] with no Higgs-boson decay
7899 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7900 } else if (fstate == 1){
7901 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7902 dBrHXXRatio1 = BrHXXRatio - 1.0;
7903 dBrHXXRatio2 = 0.0;
7904 } else if (fstate == 2){
7905 BrHXXRatio = (myNPbase->BrHgagaRatio());
7906 dBrHXXRatio1 = BrHXXRatio - 1.0;
7907 dBrHXXRatio2 = 0.0;
7908 } else if (fstate == 3){
7909 BrHXXRatio = (myNPbase->BrHbbRatio());
7910 dBrHXXRatio1 = BrHXXRatio - 1.0;
7911 dBrHXXRatio2 = 0.0;
7912 } else if (fstate == 4){
7913 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7914 dBrHXXRatio1 = BrHXXRatio - 1.0;
7915 dBrHXXRatio2 = 0.0;
7916 } else if (fstate == 5){
7917 BrHXXRatio = (myNPbase->BrHtautauRatio());
7918 dBrHXXRatio1 = BrHXXRatio - 1.0;
7919 dBrHXXRatio2 = 0.0;
7920 }else {
7921 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7922 }
7923
7924 //-- Production x Decay:
7925 if ((this->getModel()).isModelLinearized()){
7926 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7927 } else if((this->getModel()).isModelNPquadratic()){
7928 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7929 } else {
7930 return weight*(muProd)*(BrHXXRatio);
7931 }
7932
7933}
7934
7935
7936
7937
7938//VM:STXS2024;
7939STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7940: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7941{
7942 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7943 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7944
7945}
7946
7948{
7949 //-- Production:
7950 double weight = 1.0; //If normalized to the SM
7951 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7952 //We should weight each xsection with the SM prediction. We need to check
7953 //this values, nevertheless, the difference between the two parametrisations
7954 //is extremely small (way beyond our current precision)
7957 /(2.);
7958 double muProd1 = muProd -1.0;
7959 double muProd2 = 0.0;
7960
7961 //-- Decay:
7962 double BrHXXRatio = 1.0;
7963 double dBrHXXRatio1 = 0.0;
7964 double dBrHXXRatio2 = 0.0;
7965 if (fstate==0){
7966 // Use for Cross-section [pb] with no Higgs-boson decay
7967 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7968 } else if (fstate == 1){
7969 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7970 dBrHXXRatio1 = BrHXXRatio - 1.0;
7971 dBrHXXRatio2 = 0.0;
7972 } else if (fstate == 2){
7973 BrHXXRatio = (myNPbase->BrHgagaRatio());
7974 dBrHXXRatio1 = BrHXXRatio - 1.0;
7975 dBrHXXRatio2 = 0.0;
7976 } else if (fstate == 3){
7977 BrHXXRatio = (myNPbase->BrHbbRatio());
7978 dBrHXXRatio1 = BrHXXRatio - 1.0;
7979 dBrHXXRatio2 = 0.0;
7980 } else if (fstate == 4){
7981 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7982 dBrHXXRatio1 = BrHXXRatio - 1.0;
7983 dBrHXXRatio2 = 0.0;
7984 } else if (fstate == 5){
7985 BrHXXRatio = (myNPbase->BrHtautauRatio());
7986 dBrHXXRatio1 = BrHXXRatio - 1.0;
7987 dBrHXXRatio2 = 0.0;
7988 } else if (fstate == 6){
7989 BrHXXRatio = (myNPbase->BrHWWRatio());
7990 dBrHXXRatio1 = BrHXXRatio - 1.0;
7991 dBrHXXRatio2 = 0.0;
7992 } else if (fstate == 7){
7993 BrHXXRatio = (myNPbase->BrHZZRatio());
7994 dBrHXXRatio1 = BrHXXRatio - 1.0;
7995 dBrHXXRatio2 = 0.0;
7996 } else {
7997 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7998 }
7999
8000 //-- Production x Decay:
8001 if ((this->getModel()).isModelLinearized()){
8002 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8003 } else if((this->getModel()).isModelNPquadratic()){
8004 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8005 } else {
8006 return weight*(muProd)*(BrHXXRatio);
8007 }
8008
8009}
8010
8011
8012// -----------------------------------------------------------------------------
8013
8015: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8016{
8017 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8018 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8019
8020}
8021
8023{
8024 double BrHXXRatio = 1.0;
8025 if (fstate == 1){
8026 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8027 } else if (fstate == 2){
8028 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8029 } else if (fstate == 3){
8030 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8031 } else if (fstate == 4){
8032 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8033 } else {
8034 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8035 }
8036
8037 if ((this->getModel()).isModelLinearized()) {
8038 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8039 } else {
8041 }
8042}
8043
8044// -----------------------------------------------------------------------------
8045
8047: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8048{
8049
8050 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8051 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8052
8053}
8054
8056{
8057 double BrHXXRatio = 1.0;
8058 if (fstate == 1){
8059 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8060 } else if (fstate == 2){
8061 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8062 } else if (fstate == 3){
8063 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8064 } else if (fstate == 4){
8065 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8066 } else {
8067 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8068 }
8069
8070 if ((this->getModel()).isModelLinearized()) {
8071 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8072 } else {
8074 }
8075}
8076
8077// -----------------------------------------------------------------------------
8078
8080: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8081{
8082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8083 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8084
8085}
8086
8088{
8089 double BrHXXRatio = 1.0;
8090 if (fstate == 1){
8091 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8092 } else if (fstate == 2){
8093 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8094 } else if (fstate == 3){
8095 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8096 } else if (fstate == 4){
8097 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8098 } else {
8099 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8100 }
8101
8102 if ((this->getModel()).isModelLinearized()) {
8103 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8104 } else {
8106 }
8107}
8108
8109// -----------------------------------------------------------------------------
8110
8112: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8113{
8114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8115 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8116
8117}
8118
8120{
8121 double BrHXXRatio = 1.0;
8122 if (fstate == 1){
8123 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8124 } else if (fstate == 2){
8125 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8126 } else if (fstate == 3){
8127 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8128 } else if (fstate == 4){
8129 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8130 } else {
8131 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8132 }
8133
8134 if ((this->getModel()).isModelLinearized()) {
8135 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8136 } else {
8138 }
8139}
8140
8141
8142
8143
8144
8145// -----------------------------------------------------------------------------
8146
8147//VM:STXS2024;
8148STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8149: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8150{
8151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8152 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8153
8154}
8155
8157{
8158
8159
8160
8161 //-- Production:
8162 double weight = 1.0; //If normalized to the SM
8163 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8164 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8165 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8166 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8167 //The possible error that we could be introducing here is way below our precision!
8168 double muProd = (
8172 )/(2.9636+0.94321+0.87751);
8173 double muProd1 = muProd -1.0;
8174 double muProd2 = 0.0;
8175
8176 //-- Decay:
8177 double BrHXXRatio = 1.0;
8178 double dBrHXXRatio1 = 0.0;
8179 double dBrHXXRatio2 = 0.0;
8180 if (fstate==0){
8181 // Use for Cross-section [pb] with no Higgs-boson decay
8182 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8183 } else if (fstate == 1){
8184 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8185 dBrHXXRatio1 = BrHXXRatio - 1.0;
8186 dBrHXXRatio2 = 0.0;
8187 } else if (fstate == 2){
8188 BrHXXRatio = (myNPbase->BrHgagaRatio());
8189 dBrHXXRatio1 = BrHXXRatio - 1.0;
8190 dBrHXXRatio2 = 0.0;
8191 } else if (fstate == 3){
8192 BrHXXRatio = (myNPbase->BrHbbRatio());
8193 dBrHXXRatio1 = BrHXXRatio - 1.0;
8194 dBrHXXRatio2 = 0.0;
8195 } else if (fstate == 4){
8196 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8197 dBrHXXRatio1 = BrHXXRatio - 1.0;
8198 dBrHXXRatio2 = 0.0;
8199 } else if (fstate == 5){
8200 BrHXXRatio = (myNPbase->BrHtautauRatio());
8201 dBrHXXRatio1 = BrHXXRatio - 1.0;
8202 dBrHXXRatio2 = 0.0;
8203 } else if (fstate == 6){
8204 BrHXXRatio = (myNPbase->BrHWWRatio());
8205 dBrHXXRatio1 = BrHXXRatio - 1.0;
8206 dBrHXXRatio2 = 0.0;
8207 } else if (fstate == 7){
8208 BrHXXRatio = (myNPbase->BrHZZRatio());
8209 dBrHXXRatio1 = BrHXXRatio - 1.0;
8210 dBrHXXRatio2 = 0.0;
8211 } else {
8212 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8213 }
8214
8215 //-- Production x Decay:
8216 if ((this->getModel()).isModelLinearized()){
8217 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8218 } else if((this->getModel()).isModelNPquadratic()){
8219 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8220 } else {
8221 return weight*(muProd)*(BrHXXRatio);
8222 }
8223
8224}
8225
8226
8227
8228
8229
8230
8231
8232// -----------------------------------------------------------------------------
8233
8234
8235//VM:STXS2024;
8236STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8237: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8238{
8239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8240 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8241
8242}
8243
8245{
8246 //-- Production:
8247 double weight = 1.0; //If normalized to the SM
8248 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8249 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8252 /(0.45825 + 0.10632 + 0.017974);
8253 double muProd1 = muProd -1.0;
8254 double muProd2 = 0.0;
8255
8256 //-- Decay:
8257 double BrHXXRatio = 1.0;
8258 double dBrHXXRatio1 = 0.0;
8259 double dBrHXXRatio2 = 0.0;
8260 if (fstate==0){
8261 // Use for Cross-section [pb] with no Higgs-boson decay
8262 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8263 } else if (fstate == 1){
8264 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8265 dBrHXXRatio1 = BrHXXRatio - 1.0;
8266 dBrHXXRatio2 = 0.0;
8267 } else if (fstate == 2){
8268 BrHXXRatio = (myNPbase->BrHgagaRatio());
8269 dBrHXXRatio1 = BrHXXRatio - 1.0;
8270 dBrHXXRatio2 = 0.0;
8271 } else if (fstate == 3){
8272 BrHXXRatio = (myNPbase->BrHbbRatio());
8273 dBrHXXRatio1 = BrHXXRatio - 1.0;
8274 dBrHXXRatio2 = 0.0;
8275 } else if (fstate == 4){
8276 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8277 dBrHXXRatio1 = BrHXXRatio - 1.0;
8278 dBrHXXRatio2 = 0.0;
8279 } else if (fstate == 5){
8280 BrHXXRatio = (myNPbase->BrHtautauRatio());
8281 dBrHXXRatio1 = BrHXXRatio - 1.0;
8282 dBrHXXRatio2 = 0.0;
8283 } else if (fstate == 6){
8284 BrHXXRatio = (myNPbase->BrHWWRatio());
8285 dBrHXXRatio1 = BrHXXRatio - 1.0;
8286 dBrHXXRatio2 = 0.0;
8287 } else if (fstate == 7){
8288 BrHXXRatio = (myNPbase->BrHZZRatio());
8289 dBrHXXRatio1 = BrHXXRatio - 1.0;
8290 dBrHXXRatio2 = 0.0;
8291 } else {
8292 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8293 }
8294
8295 //-- Production x Decay:
8296 if ((this->getModel()).isModelLinearized()){
8297 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8298 } else if((this->getModel()).isModelNPquadratic()){
8299 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8300 } else {
8301 return weight*(muProd)*(BrHXXRatio);
8302 }
8303
8304}
8305
8306
8307
8308
8309// -----------------------------------------------------------------------------
8310
8311
8312//VM:STXS2024;
8313STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8314: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8315{
8316 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8317 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8318
8319}
8320
8322{
8323 //-- Production:
8324 double weight = 1.0; //If normalized to the SM
8325 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8326 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8328 /(0.10632 + 0.017974);
8329 double muProd1 = muProd -1.0;
8330 double muProd2 = 0.0;
8331
8332 //-- Decay:
8333 double BrHXXRatio = 1.0;
8334 double dBrHXXRatio1 = 0.0;
8335 double dBrHXXRatio2 = 0.0;
8336 if (fstate==0){
8337 // Use for Cross-section [pb] with no Higgs-boson decay
8338 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8339 } else if (fstate == 1){
8340 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8341 dBrHXXRatio1 = BrHXXRatio - 1.0;
8342 dBrHXXRatio2 = 0.0;
8343 } else if (fstate == 2){
8344 BrHXXRatio = (myNPbase->BrHgagaRatio());
8345 dBrHXXRatio1 = BrHXXRatio - 1.0;
8346 dBrHXXRatio2 = 0.0;
8347 } else if (fstate == 3){
8348 BrHXXRatio = (myNPbase->BrHbbRatio());
8349 dBrHXXRatio1 = BrHXXRatio - 1.0;
8350 dBrHXXRatio2 = 0.0;
8351 } else if (fstate == 4){
8352 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8353 dBrHXXRatio1 = BrHXXRatio - 1.0;
8354 dBrHXXRatio2 = 0.0;
8355 } else if (fstate == 5){
8356 BrHXXRatio = (myNPbase->BrHtautauRatio());
8357 dBrHXXRatio1 = BrHXXRatio - 1.0;
8358 dBrHXXRatio2 = 0.0;
8359 } else if (fstate == 6){
8360 BrHXXRatio = (myNPbase->BrHWWRatio());
8361 dBrHXXRatio1 = BrHXXRatio - 1.0;
8362 dBrHXXRatio2 = 0.0;
8363 } else if (fstate == 7){
8364 BrHXXRatio = (myNPbase->BrHZZRatio());
8365 dBrHXXRatio1 = BrHXXRatio - 1.0;
8366 dBrHXXRatio2 = 0.0;
8367 } else {
8368 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8369 }
8370
8371 //-- Production x Decay:
8372 if ((this->getModel()).isModelLinearized()){
8373 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8374 } else if((this->getModel()).isModelNPquadratic()){
8375 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8376 } else {
8377 return weight*(muProd)*(BrHXXRatio);
8378 }
8379
8380}
8381
8382
8383// -----------------------------------------------------------------------------
8384
8385
8386//VM:STXS2024;
8387STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8388: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8389{
8390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8391 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8392
8393}
8394
8396{
8397 //-- Production:
8398 double weight = 1.0; //If normalized to the SM
8399 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8400 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8401 double muProd1 = muProd -1.0;
8402 double muProd2 = 0.0;
8403
8404 //-- Decay:
8405 double BrHXXRatio = 1.0;
8406 double dBrHXXRatio1 = 0.0;
8407 double dBrHXXRatio2 = 0.0;
8408 if (fstate==0){
8409 // Use for Cross-section [pb] with no Higgs-boson decay
8410 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8411 } else if (fstate == 1){
8412 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8413 dBrHXXRatio1 = BrHXXRatio - 1.0;
8414 dBrHXXRatio2 = 0.0;
8415 } else if (fstate == 2){
8416 BrHXXRatio = (myNPbase->BrHgagaRatio());
8417 dBrHXXRatio1 = BrHXXRatio - 1.0;
8418 dBrHXXRatio2 = 0.0;
8419 } else if (fstate == 3){
8420 BrHXXRatio = (myNPbase->BrHbbRatio());
8421 dBrHXXRatio1 = BrHXXRatio - 1.0;
8422 dBrHXXRatio2 = 0.0;
8423 } else if (fstate == 4){
8424 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8425 dBrHXXRatio1 = BrHXXRatio - 1.0;
8426 dBrHXXRatio2 = 0.0;
8427 } else if (fstate == 5){
8428 BrHXXRatio = (myNPbase->BrHtautauRatio());
8429 dBrHXXRatio1 = BrHXXRatio - 1.0;
8430 dBrHXXRatio2 = 0.0;
8431 } else if (fstate == 6){
8432 BrHXXRatio = (myNPbase->BrHWWRatio());
8433 dBrHXXRatio1 = BrHXXRatio - 1.0;
8434 dBrHXXRatio2 = 0.0;
8435 } else if (fstate == 7){
8436 BrHXXRatio = (myNPbase->BrHZZRatio());
8437 dBrHXXRatio1 = BrHXXRatio - 1.0;
8438 dBrHXXRatio2 = 0.0;
8439 } else {
8440 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8441 }
8442
8443 //-- Production x Decay:
8444 if ((this->getModel()).isModelLinearized()){
8445 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8446 } else if((this->getModel()).isModelNPquadratic()){
8447 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8448 } else {
8449 return weight*(muProd)*(BrHXXRatio);
8450 }
8451
8452}
8453
8454
8455
8456// -----------------------------------------------------------------------------
8457
8458
8459//VM:STXS2024;
8460STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8461: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8462{
8463 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8464 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8465
8466}
8467
8469{
8470 //-- Production:
8471 double weight = 1.0; //If normalized to the SM
8472 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8473 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8474 double muProd1 = muProd -1.0;
8475 double muProd2 = 0.0;
8476
8477 //-- Decay:
8478 double BrHXXRatio = 1.0;
8479 double dBrHXXRatio1 = 0.0;
8480 double dBrHXXRatio2 = 0.0;
8481 if (fstate==0){
8482 // Use for Cross-section [pb] with no Higgs-boson decay
8483 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8484 } else if (fstate == 1){
8485 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8486 dBrHXXRatio1 = BrHXXRatio - 1.0;
8487 dBrHXXRatio2 = 0.0;
8488 } else if (fstate == 2){
8489 BrHXXRatio = (myNPbase->BrHgagaRatio());
8490 dBrHXXRatio1 = BrHXXRatio - 1.0;
8491 dBrHXXRatio2 = 0.0;
8492 } else if (fstate == 3){
8493 BrHXXRatio = (myNPbase->BrHbbRatio());
8494 dBrHXXRatio1 = BrHXXRatio - 1.0;
8495 dBrHXXRatio2 = 0.0;
8496 } else if (fstate == 4){
8497 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8498 dBrHXXRatio1 = BrHXXRatio - 1.0;
8499 dBrHXXRatio2 = 0.0;
8500 } else if (fstate == 5){
8501 BrHXXRatio = (myNPbase->BrHtautauRatio());
8502 dBrHXXRatio1 = BrHXXRatio - 1.0;
8503 dBrHXXRatio2 = 0.0;
8504 } else if (fstate == 6){
8505 BrHXXRatio = (myNPbase->BrHWWRatio());
8506 dBrHXXRatio1 = BrHXXRatio - 1.0;
8507 dBrHXXRatio2 = 0.0;
8508 } else if (fstate == 7){
8509 BrHXXRatio = (myNPbase->BrHZZRatio());
8510 dBrHXXRatio1 = BrHXXRatio - 1.0;
8511 dBrHXXRatio2 = 0.0;
8512 } else {
8513 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8514 }
8515
8516 //-- Production x Decay:
8517 if ((this->getModel()).isModelLinearized()){
8518 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8519 } else if((this->getModel()).isModelNPquadratic()){
8520 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8521 } else {
8522 return weight*(muProd)*(BrHXXRatio);
8523 }
8524
8525}
8526
8527
8528
8529
8530// -----------------------------------------------------------------------------
8531
8532
8533//VM:STXS2024;
8534STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8535: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8536{
8537 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8538 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8539
8540}
8541
8543{
8544 //-- Production:
8545 double weight = 1.0; //If normalized to the SM
8546 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8547 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8548 double muProd1 = muProd -1.0;
8549 double muProd2 = 0.0;
8550
8551 //-- Decay:
8552 double BrHXXRatio = 1.0;
8553 double dBrHXXRatio1 = 0.0;
8554 double dBrHXXRatio2 = 0.0;
8555 if (fstate==0){
8556 // Use for Cross-section [pb] with no Higgs-boson decay
8557 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8558 } else if (fstate == 1){
8559 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8560 dBrHXXRatio1 = BrHXXRatio - 1.0;
8561 dBrHXXRatio2 = 0.0;
8562 } else if (fstate == 2){
8563 BrHXXRatio = (myNPbase->BrHgagaRatio());
8564 dBrHXXRatio1 = BrHXXRatio - 1.0;
8565 dBrHXXRatio2 = 0.0;
8566 } else if (fstate == 3){
8567 BrHXXRatio = (myNPbase->BrHbbRatio());
8568 dBrHXXRatio1 = BrHXXRatio - 1.0;
8569 dBrHXXRatio2 = 0.0;
8570 } else if (fstate == 4){
8571 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8572 dBrHXXRatio1 = BrHXXRatio - 1.0;
8573 dBrHXXRatio2 = 0.0;
8574 } else if (fstate == 5){
8575 BrHXXRatio = (myNPbase->BrHtautauRatio());
8576 dBrHXXRatio1 = BrHXXRatio - 1.0;
8577 dBrHXXRatio2 = 0.0;
8578 } else if (fstate == 6){
8579 BrHXXRatio = (myNPbase->BrHWWRatio());
8580 dBrHXXRatio1 = BrHXXRatio - 1.0;
8581 dBrHXXRatio2 = 0.0;
8582 } else if (fstate == 7){
8583 BrHXXRatio = (myNPbase->BrHZZRatio());
8584 dBrHXXRatio1 = BrHXXRatio - 1.0;
8585 dBrHXXRatio2 = 0.0;
8586 } else {
8587 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8588 }
8589
8590 //-- Production x Decay:
8591 if ((this->getModel()).isModelLinearized()){
8592 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8593 } else if((this->getModel()).isModelNPquadratic()){
8594 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8595 } else {
8596 return weight*(muProd)*(BrHXXRatio);
8597 }
8598
8599}
8600
8601
8602
8603// -----------------------------------------------------------------------------
8604
8605
8606//VM:STXS2024;
8607STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8608: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8609{
8610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8611 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8612
8613}
8614
8616{
8617 //-- Production:
8618 double weight = 1.0; //If normalized to the SM
8619 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8620 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8621 double muProd1 = muProd -1.0;
8622 double muProd2 = 0.0;
8623
8624 //-- Decay:
8625 double BrHXXRatio = 1.0;
8626 double dBrHXXRatio1 = 0.0;
8627 double dBrHXXRatio2 = 0.0;
8628 if (fstate==0){
8629 // Use for Cross-section [pb] with no Higgs-boson decay
8630 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8631 } else if (fstate == 1){
8632 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8633 dBrHXXRatio1 = BrHXXRatio - 1.0;
8634 dBrHXXRatio2 = 0.0;
8635 } else if (fstate == 2){
8636 BrHXXRatio = (myNPbase->BrHgagaRatio());
8637 dBrHXXRatio1 = BrHXXRatio - 1.0;
8638 dBrHXXRatio2 = 0.0;
8639 } else if (fstate == 3){
8640 BrHXXRatio = (myNPbase->BrHbbRatio());
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8642 dBrHXXRatio2 = 0.0;
8643 } else if (fstate == 4){
8644 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8646 dBrHXXRatio2 = 0.0;
8647 } else if (fstate == 5){
8648 BrHXXRatio = (myNPbase->BrHtautauRatio());
8649 dBrHXXRatio1 = BrHXXRatio - 1.0;
8650 dBrHXXRatio2 = 0.0;
8651 } else if (fstate == 6){
8652 BrHXXRatio = (myNPbase->BrHWWRatio());
8653 dBrHXXRatio1 = BrHXXRatio - 1.0;
8654 dBrHXXRatio2 = 0.0;
8655 } else if (fstate == 7){
8656 BrHXXRatio = (myNPbase->BrHZZRatio());
8657 dBrHXXRatio1 = BrHXXRatio - 1.0;
8658 dBrHXXRatio2 = 0.0;
8659 } else {
8660 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8661 }
8662
8663 //-- Production x Decay:
8664 if ((this->getModel()).isModelLinearized()){
8665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8666 } else if((this->getModel()).isModelNPquadratic()){
8667 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8668 } else {
8669 return weight*(muProd)*(BrHXXRatio);
8670 }
8671
8672}
8673
8674
8675
8676// -----------------------------------------------------------------------------
8677
8678
8679//VM:STXS2024;
8680STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8681: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8682{
8683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8684 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8685
8686}
8687
8689{
8690 //-- Production:
8691 double weight = 1.0; //If normalized to the SM
8692 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8693 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8694 double muProd1 = muProd -1.0;
8695 double muProd2 = 0.0;
8696
8697 //-- Decay:
8698 double BrHXXRatio = 1.0;
8699 double dBrHXXRatio1 = 0.0;
8700 double dBrHXXRatio2 = 0.0;
8701 if (fstate==0){
8702 // Use for Cross-section [pb] with no Higgs-boson decay
8703 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8704 } else if (fstate == 1){
8705 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8706 dBrHXXRatio1 = BrHXXRatio - 1.0;
8707 dBrHXXRatio2 = 0.0;
8708 } else if (fstate == 2){
8709 BrHXXRatio = (myNPbase->BrHgagaRatio());
8710 dBrHXXRatio1 = BrHXXRatio - 1.0;
8711 dBrHXXRatio2 = 0.0;
8712 } else if (fstate == 3){
8713 BrHXXRatio = (myNPbase->BrHbbRatio());
8714 dBrHXXRatio1 = BrHXXRatio - 1.0;
8715 dBrHXXRatio2 = 0.0;
8716 } else if (fstate == 4){
8717 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8718 dBrHXXRatio1 = BrHXXRatio - 1.0;
8719 dBrHXXRatio2 = 0.0;
8720 } else if (fstate == 5){
8721 BrHXXRatio = (myNPbase->BrHtautauRatio());
8722 dBrHXXRatio1 = BrHXXRatio - 1.0;
8723 dBrHXXRatio2 = 0.0;
8724 } else if (fstate == 6){
8725 BrHXXRatio = (myNPbase->BrHWWRatio());
8726 dBrHXXRatio1 = BrHXXRatio - 1.0;
8727 dBrHXXRatio2 = 0.0;
8728 } else if (fstate == 7){
8729 BrHXXRatio = (myNPbase->BrHZZRatio());
8730 dBrHXXRatio1 = BrHXXRatio - 1.0;
8731 dBrHXXRatio2 = 0.0;
8732 } else {
8733 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8734 }
8735
8736 //-- Production x Decay:
8737 if ((this->getModel()).isModelLinearized()){
8738 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8739 } else if((this->getModel()).isModelNPquadratic()){
8740 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8741 } else {
8742 return weight*(muProd)*(BrHXXRatio);
8743 }
8744
8745}
8746
8747
8748// -----------------------------------------------------------------------------
8749
8750STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8751: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8752{
8753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8754 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8755
8756}
8757
8759{
8760 double BrHXXRatio = 1.0;
8761 if (fstate == 1){
8762 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8763 } else if (fstate == 2){
8764 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8765 } else if (fstate == 3){
8766 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8767 } else if (fstate == 4){
8768 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8769 } else {
8770 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8771 }
8772
8773 if ((this->getModel()).isModelLinearized()) {
8774 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8775 } else {
8776 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8777 }
8778}
8779
8780// -----------------------------------------------------------------------------
8781
8782STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8783: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8784{
8785 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8786 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8787
8788}
8789
8791{
8792 double BrHXXRatio = 1.0;
8793 if (fstate == 1){
8794 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8795 } else if (fstate == 2){
8796 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8797 } else if (fstate == 3){
8798 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8799 } else if (fstate == 4){
8800 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8801 } else {
8802 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8803 }
8804
8805 if ((this->getModel()).isModelLinearized()) {
8806 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8807 } else {
8808 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8809 }
8810}
8811
8812// -----------------------------------------------------------------------------
8813
8814STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8815: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8816{
8817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8818 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8819
8820}
8821
8823{
8824 double BrHXXRatio = 1.0;
8825 if (fstate == 1){
8826 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8827 } else if (fstate == 2){
8828 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8829 } else if (fstate == 3){
8830 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8831 } else if (fstate == 4){
8832 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8833 } else {
8834 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8835 }
8836
8837 if ((this->getModel()).isModelLinearized()) {
8838 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8839 } else {
8840 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8841 }
8842}
8843
8844// -----------------------------------------------------------------------------
8845
8846STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8847: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8848{
8849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8850 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8851
8852}
8853
8855{
8856 double BrHXXRatio = 1.0;
8857 if (fstate == 1){
8858 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8859 } else if (fstate == 2){
8860 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8861 } else if (fstate == 3){
8862 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8863 } else if (fstate == 4){
8864 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8865 } else {
8866 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8867 }
8868
8869 if ((this->getModel()).isModelLinearized()) {
8870 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8871 } else {
8872 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8873 }
8874}
8875
8876// -----------------------------------------------------------------------------
8877
8878STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8879: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8880{
8881 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8882 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8883
8884}
8885
8887{
8888 double BrHXXRatio = 1.0;
8889 if (fstate == 1){
8890 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8891 } else if (fstate == 2){
8892 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8893 } else if (fstate == 3){
8894 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8895 } else if (fstate == 4){
8896 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8897 } else {
8898 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8899 }
8900
8901 if ((this->getModel()).isModelLinearized()) {
8902 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8903 } else {
8904 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8905 }
8906}
8907
8908// -----------------------------------------------------------------------------
8909
8910STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8911: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8912{
8913 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8914 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8915
8916}
8917
8919{
8920 double BrHXXRatio = 1.0;
8921 if (fstate == 1){
8922 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8923 } else if (fstate == 2){
8924 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8925 } else if (fstate == 3){
8926 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8927 } else if (fstate == 4){
8928 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8929 } else {
8930 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8931 }
8932
8933 if ((this->getModel()).isModelLinearized()) {
8934 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8935 } else {
8936 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8937 }
8938}
8939
8940// -----------------------------------------------------------------------------
8941
8942STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8943: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8944{
8945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8946 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8947
8948}
8949
8951{
8952 double BrHXXRatio = 1.0;
8953 if (fstate == 1){
8954 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8955 } else if (fstate == 2){
8956 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8957 } else if (fstate == 3){
8958 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8959 } else if (fstate == 4){
8960 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8961 } else {
8962 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8963 }
8964
8965 if ((this->getModel()).isModelLinearized()) {
8966 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8967 } else {
8968 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8969 }
8970}
8971
8972// -----------------------------------------------------------------------------
8973
8974STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8975: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8976{
8977 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8978 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8979
8980}
8981
8983{
8984 double BrHXXRatio = 1.0;
8985 if (fstate == 1){
8986 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8987 } else if (fstate == 2){
8988 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8989 } else if (fstate == 3){
8990 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8991 } else if (fstate == 4){
8992 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8993 } else {
8994 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8995 }
8996
8997 if ((this->getModel()).isModelLinearized()) {
8998 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8999 } else {
9000 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
9001 }
9002}
9003
9004
9005
9006// -----------------------------------------------------------------------------
9007
9008
9009//VM:STXS2024;
9010STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9011: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9012{
9013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9014 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9015
9016}
9017
9019{
9020 //-- Production:
9021 double weight = 1.0; //If normalized to the SM
9022 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9023 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9024 double muProd1 = muProd -1.0;
9025 double muProd2 = 0.0;
9026
9027 //-- Decay:
9028 double BrHXXRatio = 1.0;
9029 double dBrHXXRatio1 = 0.0;
9030 double dBrHXXRatio2 = 0.0;
9031 if (fstate==0){
9032 // Use for Cross-section [pb] with no Higgs-boson decay
9033 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9034 } else if (fstate == 1){
9035 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9036 dBrHXXRatio1 = BrHXXRatio - 1.0;
9037 dBrHXXRatio2 = 0.0;
9038 } else if (fstate == 2){
9039 BrHXXRatio = (myNPbase->BrHgagaRatio());
9040 dBrHXXRatio1 = BrHXXRatio - 1.0;
9041 dBrHXXRatio2 = 0.0;
9042 } else if (fstate == 3){
9043 BrHXXRatio = (myNPbase->BrHbbRatio());
9044 dBrHXXRatio1 = BrHXXRatio - 1.0;
9045 dBrHXXRatio2 = 0.0;
9046 } else if (fstate == 4){
9047 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9048 dBrHXXRatio1 = BrHXXRatio - 1.0;
9049 dBrHXXRatio2 = 0.0;
9050 } else if (fstate == 5){
9051 BrHXXRatio = (myNPbase->BrHtautauRatio());
9052 dBrHXXRatio1 = BrHXXRatio - 1.0;
9053 dBrHXXRatio2 = 0.0;
9054 } else if (fstate == 6){
9055 BrHXXRatio = (myNPbase->BrHWWRatio());
9056 dBrHXXRatio1 = BrHXXRatio - 1.0;
9057 dBrHXXRatio2 = 0.0;
9058 } else if (fstate == 7){
9059 BrHXXRatio = (myNPbase->BrHZZRatio());
9060 dBrHXXRatio1 = BrHXXRatio - 1.0;
9061 dBrHXXRatio2 = 0.0;
9062 } else {
9063 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9064 }
9065
9066 //-- Production x Decay:
9067 if ((this->getModel()).isModelLinearized()){
9068 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9069 } else if((this->getModel()).isModelNPquadratic()){
9070 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9071 } else {
9072 return weight*(muProd)*(BrHXXRatio);
9073 }
9074
9075}
9076
9077
9078
9079
9080// -----------------------------------------------------------------------------
9081
9082
9083//VM:STXS2024;
9084STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9085: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9086{
9087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9088 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9089
9090}
9091
9093{
9094 //-- Production:
9095 double weight = 1.0; //If normalized to the SM
9096 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9097 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9098 double muProd1 = muProd -1.0;
9099 double muProd2 = 0.0;
9100
9101 //-- Decay:
9102 double BrHXXRatio = 1.0;
9103 double dBrHXXRatio1 = 0.0;
9104 double dBrHXXRatio2 = 0.0;
9105 if (fstate==0){
9106 // Use for Cross-section [pb] with no Higgs-boson decay
9107 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9108 } else if (fstate == 1){
9109 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9110 dBrHXXRatio1 = BrHXXRatio - 1.0;
9111 dBrHXXRatio2 = 0.0;
9112 } else if (fstate == 2){
9113 BrHXXRatio = (myNPbase->BrHgagaRatio());
9114 dBrHXXRatio1 = BrHXXRatio - 1.0;
9115 dBrHXXRatio2 = 0.0;
9116 } else if (fstate == 3){
9117 BrHXXRatio = (myNPbase->BrHbbRatio());
9118 dBrHXXRatio1 = BrHXXRatio - 1.0;
9119 dBrHXXRatio2 = 0.0;
9120 } else if (fstate == 4){
9121 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9122 dBrHXXRatio1 = BrHXXRatio - 1.0;
9123 dBrHXXRatio2 = 0.0;
9124 } else if (fstate == 5){
9125 BrHXXRatio = (myNPbase->BrHtautauRatio());
9126 dBrHXXRatio1 = BrHXXRatio - 1.0;
9127 dBrHXXRatio2 = 0.0;
9128 } else if (fstate == 6){
9129 BrHXXRatio = (myNPbase->BrHWWRatio());
9130 dBrHXXRatio1 = BrHXXRatio - 1.0;
9131 dBrHXXRatio2 = 0.0;
9132 } else if (fstate == 7){
9133 BrHXXRatio = (myNPbase->BrHZZRatio());
9134 dBrHXXRatio1 = BrHXXRatio - 1.0;
9135 dBrHXXRatio2 = 0.0;
9136 } else {
9137 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9138 }
9139
9140 //-- Production x Decay:
9141 if ((this->getModel()).isModelLinearized()){
9142 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9143 } else if((this->getModel()).isModelNPquadratic()){
9144 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9145 } else {
9146 return weight*(muProd)*(BrHXXRatio);
9147 }
9148
9149}
9150
9151
9152
9153// -----------------------------------------------------------------------------
9154
9155//AG:STXS2024
9156STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9157: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9158{
9159 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9160 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9161
9162}
9163
9165{
9166 //-- Production:
9167 double weight = 1.0; //If normalized to the SM
9168 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9169 double muProd1 = muProd -1.0;
9170 double muProd2 = 0.0;
9171
9172 //-- Decay:
9173 double BrHXXRatio = 1.0;
9174 double dBrHXXRatio1 = 0.0;
9175 double dBrHXXRatio2 = 0.0;
9176 if (fstate==0){
9177 // Use for Cross-section [pb] with no Higgs-boson decay
9178 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9179 } else if (fstate == 1){
9180 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9181 dBrHXXRatio1 = BrHXXRatio - 1.0;
9182 dBrHXXRatio2 = 0.0;
9183 } else if (fstate == 2){
9184 BrHXXRatio = (myNPbase->BrHgagaRatio());
9185 dBrHXXRatio1 = BrHXXRatio - 1.0;
9186 dBrHXXRatio2 = 0.0;
9187 } else if (fstate == 3){
9188 BrHXXRatio = (myNPbase->BrHbbRatio());
9189 dBrHXXRatio1 = BrHXXRatio - 1.0;
9190 dBrHXXRatio2 = 0.0;
9191 } else if (fstate == 4){
9192 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9193 dBrHXXRatio1 = BrHXXRatio - 1.0;
9194 dBrHXXRatio2 = 0.0;
9195 } else if (fstate == 5){
9196 BrHXXRatio = (myNPbase->BrHtautauRatio());
9197 dBrHXXRatio1 = BrHXXRatio - 1.0;
9198 dBrHXXRatio2 = 0.0;
9199 } else if (fstate == 6){
9200 BrHXXRatio = (myNPbase->BrHWWRatio());
9201 dBrHXXRatio1 = BrHXXRatio - 1.0;
9202 dBrHXXRatio2 = 0.0;
9203 } else if (fstate == 7){
9204 BrHXXRatio = (myNPbase->BrHZZRatio());
9205 dBrHXXRatio1 = BrHXXRatio - 1.0;
9206 dBrHXXRatio2 = 0.0;
9207 } else {
9208 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9209 }
9210
9211 //-- Production x Decay:
9212 if ((this->getModel()).isModelLinearized()){
9213 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9214 } else if((this->getModel()).isModelNPquadratic()){
9215 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9216 } else {
9217 return weight*(muProd)*(BrHXXRatio);
9218 }
9219}
9220
9221// -----------------------------------------------------------------------------
9222
9223STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9224: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9225{
9226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9227 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9228
9229}
9230
9232{
9233 double BrHXXRatio = 1.0;
9234 if (fstate == 1){
9235 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9236 } else if (fstate == 2){
9237 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9238 } else if (fstate == 3){
9239 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9240 } else if (fstate == 4){
9241 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9242 } else {
9243 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9244 }
9245
9246 if ((this->getModel()).isModelLinearized()) {
9247 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9248 } else {
9249 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9250 }
9251}
9252
9253// -----------------------------------------------------------------------------
9254
9255//AG:STXS2024
9257: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9258{
9259 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9260 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9261
9262}
9263
9265{
9266 //-- Production:
9267 double weight = 1.0; //If normalized to the SM
9269 double muProd1 = muProd -1.0;
9270 double muProd2 = 0.0;
9271
9272 //-- Decay:
9273 double BrHXXRatio = 1.0;
9274 double dBrHXXRatio1 = 0.0;
9275 double dBrHXXRatio2 = 0.0;
9276 if (fstate==0){
9277 // Use for Cross-section [pb] with no Higgs-boson decay
9278 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9279 } else if (fstate == 1){
9280 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9281 dBrHXXRatio1 = BrHXXRatio - 1.0;
9282 dBrHXXRatio2 = 0.0;
9283 } else if (fstate == 2){
9284 BrHXXRatio = (myNPbase->BrHgagaRatio());
9285 dBrHXXRatio1 = BrHXXRatio - 1.0;
9286 dBrHXXRatio2 = 0.0;
9287 } else if (fstate == 3){
9288 BrHXXRatio = (myNPbase->BrHbbRatio());
9289 dBrHXXRatio1 = BrHXXRatio - 1.0;
9290 dBrHXXRatio2 = 0.0;
9291 } else if (fstate == 4){
9292 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9293 dBrHXXRatio1 = BrHXXRatio - 1.0;
9294 dBrHXXRatio2 = 0.0;
9295 } else if (fstate == 5){
9296 BrHXXRatio = (myNPbase->BrHtautauRatio());
9297 dBrHXXRatio1 = BrHXXRatio - 1.0;
9298 dBrHXXRatio2 = 0.0;
9299 } else if (fstate == 6){
9300 BrHXXRatio = (myNPbase->BrHWWRatio());
9301 dBrHXXRatio1 = BrHXXRatio - 1.0;
9302 dBrHXXRatio2 = 0.0;
9303 } else if (fstate == 7){
9304 BrHXXRatio = (myNPbase->BrHZZRatio());
9305 dBrHXXRatio1 = BrHXXRatio - 1.0;
9306 dBrHXXRatio2 = 0.0;
9307 } else {
9308 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9309 }
9310
9311
9312 //-- Production x Decay:
9313 if ((this->getModel()).isModelLinearized()){
9314 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9315 } else if((this->getModel()).isModelNPquadratic()){
9316 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9317 } else {
9318 return weight*(muProd)*(BrHXXRatio);
9319 }
9320
9321}
9322
9323// -----------------------------------------------------------------------------
9324
9326: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9327{
9328 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9329 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9330
9331}
9332
9334{
9335 double BrHXXRatio = 1.0;
9336 if (fstate == 1){
9337 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9338 } else if (fstate == 2){
9339 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9340 } else if (fstate == 3){
9341 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9342 } else if (fstate == 4){
9343 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9344 } else {
9345 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9346 }
9347
9348 if ((this->getModel()).isModelLinearized()) {
9349 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9350 } else {
9352 }
9353}
9354
9355// -----------------------------------------------------------------------------
9356
9358: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9359{
9360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9361 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9362
9363}
9364
9366{
9367 double BrHXXRatio = 1.0;
9368 if (fstate == 1){
9369 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9370 } else if (fstate == 2){
9371 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9372 } else if (fstate == 3){
9373 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9374 } else if (fstate == 4){
9375 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9376 } else {
9377 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9378 }
9379
9380 if ((this->getModel()).isModelLinearized()) {
9381 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9382 } else {
9384 }
9385}
9386
9387// -----------------------------------------------------------------------------
9388
9390: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9391{
9392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9393 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9394
9395}
9396
9398{
9399 double BrHXXRatio = 1.0;
9400 if (fstate == 1){
9401 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9402 } else if (fstate == 2){
9403 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9404 } else if (fstate == 3){
9405 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9406 } else if (fstate == 4){
9407 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9408 } else {
9409 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9410 }
9411
9412 if ((this->getModel()).isModelLinearized()) {
9413 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9414 } else {
9416 }
9417}
9418
9419// -----------------------------------------------------------------------------
9420
9422: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9423{
9424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9425 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9426
9427}
9428
9430{
9431 double BrHXXRatio = 1.0;
9432 if (fstate == 1){
9433 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9434 } else if (fstate == 2){
9435 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9436 } else if (fstate == 3){
9437 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9438 } else if (fstate == 4){
9439 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9440 } else {
9441 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9442 }
9443
9444 if ((this->getModel()).isModelLinearized()) {
9445 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9446 } else {
9448 }
9449}
9450
9451// -----------------------------------------------------------------------------
9452
9453//AG:STXS2024
9454STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9455: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9456{
9457 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9458 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9459
9460}
9461
9463{
9464 //-- Production:
9465 double weight = 1.0; //If normalized to the SM
9467 double muProd1 = muProd -1.0;
9468 double muProd2 = 0.0;
9469
9470 //-- Decay:
9471 double BrHXXRatio = 1.0;
9472 double dBrHXXRatio1 = 0.0;
9473 double dBrHXXRatio2 = 0.0;
9474 if (fstate==0){
9475 // Use for Cross-section [pb] with no Higgs-boson decay
9476 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9477 } else if (fstate == 1){
9478 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9479 dBrHXXRatio1 = BrHXXRatio - 1.0;
9480 dBrHXXRatio2 = 0.0;
9481 } else if (fstate == 2){
9482 BrHXXRatio = (myNPbase->BrHgagaRatio());
9483 dBrHXXRatio1 = BrHXXRatio - 1.0;
9484 dBrHXXRatio2 = 0.0;
9485 } else if (fstate == 3){
9486 BrHXXRatio = (myNPbase->BrHbbRatio());
9487 dBrHXXRatio1 = BrHXXRatio - 1.0;
9488 dBrHXXRatio2 = 0.0;
9489 } else if (fstate == 4){
9490 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9491 dBrHXXRatio1 = BrHXXRatio - 1.0;
9492 dBrHXXRatio2 = 0.0;
9493 } else if (fstate == 5){
9494 BrHXXRatio = (myNPbase->BrHtautauRatio());
9495 dBrHXXRatio1 = BrHXXRatio - 1.0;
9496 dBrHXXRatio2 = 0.0;
9497 } else if (fstate == 6){
9498 BrHXXRatio = (myNPbase->BrHWWRatio());
9499 dBrHXXRatio1 = BrHXXRatio - 1.0;
9500 dBrHXXRatio2 = 0.0;
9501 } else {
9502 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9503 }
9504
9505 //-- Production x Decay:
9506 if ((this->getModel()).isModelLinearized()){
9507 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9508 } else if((this->getModel()).isModelNPquadratic()){
9509 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9510 } else {
9511 return weight*(muProd)*(BrHXXRatio);
9512 }
9513
9514
9515}
9516
9517// -----------------------------------------------------------------------------
9518
9519//AG:STXS2024
9520STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9521: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9522{
9523 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9524 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9525
9526}
9527
9529{
9530 //-- Production:
9531 double weight = 1.0; //If normalized to the SM
9533 double muProd1 = muProd -1.0;
9534 double muProd2 = 0.0;
9535
9536 //-- Decay:
9537 double BrHXXRatio = 1.0;
9538 double dBrHXXRatio1 = 0.0;
9539 double dBrHXXRatio2 = 0.0;
9540 if (fstate==0){
9541 // Use for Cross-section [pb] with no Higgs-boson decay
9542 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9543 } else if (fstate == 1){
9544 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9545 dBrHXXRatio1 = BrHXXRatio - 1.0;
9546 dBrHXXRatio2 = 0.0;
9547 } else if (fstate == 2){
9548 BrHXXRatio = (myNPbase->BrHgagaRatio());
9549 dBrHXXRatio1 = BrHXXRatio - 1.0;
9550 dBrHXXRatio2 = 0.0;
9551 } else if (fstate == 3){
9552 BrHXXRatio = (myNPbase->BrHbbRatio());
9553 dBrHXXRatio1 = BrHXXRatio - 1.0;
9554 dBrHXXRatio2 = 0.0;
9555 } else if (fstate == 4){
9556 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9557 dBrHXXRatio1 = BrHXXRatio - 1.0;
9558 dBrHXXRatio2 = 0.0;
9559 } else if (fstate == 5){
9560 BrHXXRatio = (myNPbase->BrHtautauRatio());
9561 dBrHXXRatio1 = BrHXXRatio - 1.0;
9562 dBrHXXRatio2 = 0.0;
9563 } else if (fstate == 6){
9564 BrHXXRatio = (myNPbase->BrHWWRatio());
9565 dBrHXXRatio1 = BrHXXRatio - 1.0;
9566 dBrHXXRatio2 = 0.0;
9567 } else {
9568 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9569 }
9570
9571 //-- Production x Decay:
9572 if ((this->getModel()).isModelLinearized()){
9573 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9574 } else if((this->getModel()).isModelNPquadratic()){
9575 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9576 } else {
9577 return weight*(muProd)*(BrHXXRatio);
9578 }
9579
9580
9581}
9582
9583// -----------------------------------------------------------------------------
9584
9585//AG:STXS2024
9586STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9587: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9588{
9589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9590 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9591
9592}
9593
9595{
9596 //-- Production:
9597 double weight = 1.0; //If normalized to the SM
9599 double muProd1 = muProd -1.0;
9600 double muProd2 = 0.0;
9601
9602 //-- Decay:
9603 double BrHXXRatio = 1.0;
9604 double dBrHXXRatio1 = 0.0;
9605 double dBrHXXRatio2 = 0.0;
9606 if (fstate==0){
9607 // Use for Cross-section [pb] with no Higgs-boson decay
9608 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9609 } else if (fstate == 1){
9610 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9611 dBrHXXRatio1 = BrHXXRatio - 1.0;
9612 dBrHXXRatio2 = 0.0;
9613 } else if (fstate == 2){
9614 BrHXXRatio = (myNPbase->BrHgagaRatio());
9615 dBrHXXRatio1 = BrHXXRatio - 1.0;
9616 dBrHXXRatio2 = 0.0;
9617 } else if (fstate == 3){
9618 BrHXXRatio = (myNPbase->BrHbbRatio());
9619 dBrHXXRatio1 = BrHXXRatio - 1.0;
9620 dBrHXXRatio2 = 0.0;
9621 } else if (fstate == 4){
9622 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9623 dBrHXXRatio1 = BrHXXRatio - 1.0;
9624 dBrHXXRatio2 = 0.0;
9625 } else if (fstate == 5){
9626 BrHXXRatio = (myNPbase->BrHtautauRatio());
9627 dBrHXXRatio1 = BrHXXRatio - 1.0;
9628 dBrHXXRatio2 = 0.0;
9629 } else if (fstate == 6){
9630 BrHXXRatio = (myNPbase->BrHWWRatio());
9631 dBrHXXRatio1 = BrHXXRatio - 1.0;
9632 dBrHXXRatio2 = 0.0;
9633 } else {
9634 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9635 }
9636
9637 //-- Production x Decay:
9638 if ((this->getModel()).isModelLinearized()){
9639 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9640 } else if((this->getModel()).isModelNPquadratic()){
9641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9642 } else {
9643 return weight*(muProd)*(BrHXXRatio);
9644 }
9645
9646
9647}
9648
9649// -----------------------------------------------------------------------------
9650
9651//AG:STXS2024
9652STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9653: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9654{
9655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9656 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9657
9658}
9659
9661{
9662 //-- Production:
9663 double weight = 1.0; //If normalized to the SM
9665 double muProd1 = muProd -1.0;
9666 double muProd2 = 0.0;
9667
9668 //-- Decay:
9669 double BrHXXRatio = 1.0;
9670 double dBrHXXRatio1 = 0.0;
9671 double dBrHXXRatio2 = 0.0;
9672 if (fstate==0){
9673 // Use for Cross-section [pb] with no Higgs-boson decay
9674 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9675 } else if (fstate == 1){
9676 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9678 dBrHXXRatio2 = 0.0;
9679 } else if (fstate == 2){
9680 BrHXXRatio = (myNPbase->BrHgagaRatio());
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9682 dBrHXXRatio2 = 0.0;
9683 } else if (fstate == 3){
9684 BrHXXRatio = (myNPbase->BrHbbRatio());
9685 dBrHXXRatio1 = BrHXXRatio - 1.0;
9686 dBrHXXRatio2 = 0.0;
9687 } else if (fstate == 4){
9688 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9689 dBrHXXRatio1 = BrHXXRatio - 1.0;
9690 dBrHXXRatio2 = 0.0;
9691 } else if (fstate == 5){
9692 BrHXXRatio = (myNPbase->BrHtautauRatio());
9693 dBrHXXRatio1 = BrHXXRatio - 1.0;
9694 dBrHXXRatio2 = 0.0;
9695 } else if (fstate == 6){
9696 BrHXXRatio = (myNPbase->BrHWWRatio());
9697 dBrHXXRatio1 = BrHXXRatio - 1.0;
9698 dBrHXXRatio2 = 0.0;
9699 } else {
9700 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9701 }
9702
9703 //-- Production x Decay:
9704 if ((this->getModel()).isModelLinearized()){
9705 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9706 } else if((this->getModel()).isModelNPquadratic()){
9707 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9708 } else {
9709 return weight*(muProd)*(BrHXXRatio);
9710 }
9711
9712}
9713
9714// -----------------------------------------------------------------------------
9715
9716//AG:STXS2024
9717STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9718: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9719{
9720 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9721 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9722
9723}
9724
9726{
9727 //-- Production:
9728 double weight = 1.0; //If normalized to the SM
9729 //Since adding bins, include partial weigths of SM_predictions
9730 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9731 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9732 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9733 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9734 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9735 double muProd2 = 0.0;
9736
9737 //-- Decay:
9738 double BrHXXRatio = 1.0;
9739 double dBrHXXRatio1 = 0.0;
9740 double dBrHXXRatio2 = 0.0;
9741 if (fstate==0){
9742 // Use for Cross-section [pb] with no Higgs-boson decay
9743 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9744 } else if (fstate == 1){
9745 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9746 dBrHXXRatio1 = BrHXXRatio - 1.0;
9747 dBrHXXRatio2 = 0.0;
9748 } else if (fstate == 2){
9749 BrHXXRatio = (myNPbase->BrHgagaRatio());
9750 dBrHXXRatio1 = BrHXXRatio - 1.0;
9751 dBrHXXRatio2 = 0.0;
9752 } else if (fstate == 3){
9753 BrHXXRatio = (myNPbase->BrHbbRatio());
9754 dBrHXXRatio1 = BrHXXRatio - 1.0;
9755 dBrHXXRatio2 = 0.0;
9756 } else if (fstate == 4){
9757 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9758 dBrHXXRatio1 = BrHXXRatio - 1.0;
9759 dBrHXXRatio2 = 0.0;
9760 } else {
9761 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9762 }
9763
9764 //-- Production x Decay:
9765 if ((this->getModel()).isModelLinearized()){
9766 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9767 } else if((this->getModel()).isModelNPquadratic()){
9768 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9769 } else {
9770 return weight*(muProd)*(BrHXXRatio);
9771 }
9772
9773
9774}
9775
9776// -----------------------------------------------------------------------------
9777
9778//AG:STXS2024
9779STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9780: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9781{
9782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9783 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9784
9785}
9786
9788{
9789 //-- Production:
9790 double weight = 1.0; //If normalized to the SM
9792 double muProd1 = muProd -1.0;
9793 double muProd2 = 0.0;
9794
9795 //-- Decay:
9796 double BrHXXRatio = 1.0;
9797 double dBrHXXRatio1 = 0.0;
9798 double dBrHXXRatio2 = 0.0;
9799 if (fstate==0){
9800 // Use for Cross-section [pb] with no Higgs-boson decay
9801 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9802 } else if (fstate == 1){
9803 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9804 dBrHXXRatio1 = BrHXXRatio - 1.0;
9805 dBrHXXRatio2 = 0.0;
9806 } else if (fstate == 2){
9807 BrHXXRatio = (myNPbase->BrHgagaRatio());
9808 dBrHXXRatio1 = BrHXXRatio - 1.0;
9809 dBrHXXRatio2 = 0.0;
9810 } else if (fstate == 3){
9811 BrHXXRatio = (myNPbase->BrHbbRatio());
9812 dBrHXXRatio1 = BrHXXRatio - 1.0;
9813 dBrHXXRatio2 = 0.0;
9814 } else if (fstate == 4){
9815 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9816 dBrHXXRatio1 = BrHXXRatio - 1.0;
9817 dBrHXXRatio2 = 0.0;
9818 } else {
9819 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9820 }
9821
9822 //-- Production x Decay:
9823 if ((this->getModel()).isModelLinearized()){
9824 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9825 } else if((this->getModel()).isModelNPquadratic()){
9826 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9827 } else {
9828 return weight*(muProd)*(BrHXXRatio);
9829 }
9830
9831
9832}
9833
9834// -----------------------------------------------------------------------------
9835
9836//AG:STXS2024
9837STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9838: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9839{
9840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9841 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9842
9843}
9844
9846{
9847 //-- Production:
9848 double weight = 1.0; //If normalized to the SM
9850 double muProd1 = muProd -1.0;
9851 double muProd2 = 0.0;
9852
9853 //-- Decay:
9854 double BrHXXRatio = 1.0;
9855 double dBrHXXRatio1 = 0.0;
9856 double dBrHXXRatio2 = 0.0;
9857 if (fstate==0){
9858 // Use for Cross-section [pb] with no Higgs-boson decay
9859 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9860 } else if (fstate == 1){
9861 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9862 dBrHXXRatio1 = BrHXXRatio - 1.0;
9863 dBrHXXRatio2 = 0.0;
9864 } else if (fstate == 2){
9865 BrHXXRatio = (myNPbase->BrHgagaRatio());
9866 dBrHXXRatio1 = BrHXXRatio - 1.0;
9867 dBrHXXRatio2 = 0.0;
9868 } else if (fstate == 3){
9869 BrHXXRatio = (myNPbase->BrHbbRatio());
9870 dBrHXXRatio1 = BrHXXRatio - 1.0;
9871 dBrHXXRatio2 = 0.0;
9872 } else if (fstate == 4){
9873 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9874 dBrHXXRatio1 = BrHXXRatio - 1.0;
9875 dBrHXXRatio2 = 0.0;
9876 } else {
9877 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9878 }
9879
9880 //-- Production x Decay:
9881 if ((this->getModel()).isModelLinearized()){
9882 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9883 } else if((this->getModel()).isModelNPquadratic()){
9884 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9885 } else {
9886 return weight*(muProd)*(BrHXXRatio);
9887 }
9888
9889
9890}
9891
9892// -----------------------------------------------------------------------------
9893
9894STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9895: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9896{
9897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9898 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9899
9900}
9901
9903{
9904 //-- Production:
9905 double weight = 1.0; //If normalized to the SM
9906 //Since adding bins, include partial weigths of SM_predictions
9907 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9908
9909 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9915 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9916
9917 double muProd1 = muProd - 1.;
9918 double muProd2 = 0.0;
9919
9920 //-- Decay:
9921 double BrHXXRatio = 1.0;
9922 double dBrHXXRatio1 = 0.0;
9923 double dBrHXXRatio2 = 0.0;
9924 if (fstate==0){
9925 // Use for Cross-section [pb] with no Higgs-boson decay
9926 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9927 } else if (fstate == 1){
9928 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9929 dBrHXXRatio1 = BrHXXRatio - 1.0;
9930 dBrHXXRatio2 = 0.0;
9931 } else if (fstate == 2){
9932 BrHXXRatio = (myNPbase->BrHgagaRatio());
9933 dBrHXXRatio1 = BrHXXRatio - 1.0;
9934 dBrHXXRatio2 = 0.0;
9935 } else if (fstate == 3){
9936 BrHXXRatio = (myNPbase->BrHbbRatio());
9937 dBrHXXRatio1 = BrHXXRatio - 1.0;
9938 dBrHXXRatio2 = 0.0;
9939 } else if (fstate == 4){
9940 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9941 dBrHXXRatio1 = BrHXXRatio - 1.0;
9942 dBrHXXRatio2 = 0.0;
9943 } else if (fstate == 5){
9944 BrHXXRatio = (myNPbase->BrHtautauRatio());
9945 dBrHXXRatio1 = BrHXXRatio - 1.0;
9946 dBrHXXRatio2 = 0.0;
9947 } else {
9948 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9949 }
9950
9951
9952
9953
9954 //-- Production x Decay:
9955 if ((this->getModel()).isModelLinearized()){
9956// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9957 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9958 } else if((this->getModel()).isModelNPquadratic()){
9959// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9960 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9961 } else {
9962// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9963 return weight*(muProd)*(BrHXXRatio);
9964 }
9965
9966}
9967
9968// -----------------------------------------------------------------------------
9969
9970STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9971: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9972{
9973 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9974 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9975
9976}
9977
9979{
9980 //-- Production:
9981 double weight = 1.0; //If normalized to the SM
9982 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9983 double muProd1 = muProd -1.0;
9984 double muProd2 = 0.0;
9985
9986 //-- Decay:
9987 double BrHXXRatio = 1.0;
9988 double dBrHXXRatio1 = 0.0;
9989 double dBrHXXRatio2 = 0.0;
9990 if (fstate==0){
9991 // Use for Cross-section [pb] with no Higgs-boson decay
9992 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9993 } else if (fstate == 1){
9994 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9995 dBrHXXRatio1 = BrHXXRatio - 1.0;
9996 dBrHXXRatio2 = 0.0;
9997 } else if (fstate == 2){
9998 BrHXXRatio = (myNPbase->BrHgagaRatio());
9999 dBrHXXRatio1 = BrHXXRatio - 1.0;
10000 dBrHXXRatio2 = 0.0;
10001 } else if (fstate == 3){
10002 BrHXXRatio = (myNPbase->BrHbbRatio());
10003 dBrHXXRatio1 = BrHXXRatio - 1.0;
10004 dBrHXXRatio2 = 0.0;
10005 } else if (fstate == 4){
10006 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10007 dBrHXXRatio1 = BrHXXRatio - 1.0;
10008 dBrHXXRatio2 = 0.0;
10009 } else if (fstate == 5){
10010 BrHXXRatio = (myNPbase->BrHtautauRatio());
10011 dBrHXXRatio1 = BrHXXRatio - 1.0;
10012 dBrHXXRatio2 = 0.0;
10013 } else {
10014 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10015 }
10016
10017 //-- Production x Decay:
10018 if ((this->getModel()).isModelLinearized()){
10019 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10020 } else if((this->getModel()).isModelNPquadratic()){
10021 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10022 } else {
10023 return weight*(muProd)*(BrHXXRatio);
10024 }
10025
10026}
10027
10028// -----------------------------------------------------------------------------
10029
10030STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10031: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10032{
10033 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10034 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10035
10036}
10037
10039{
10040 //-- Production:
10041 double weight = 1.0; //If normalized to the SM
10042 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10043 double muProd1 = muProd -1.0;
10044 double muProd2 = 0.0;
10045
10046 //-- Decay:
10047 double BrHXXRatio = 1.0;
10048 double dBrHXXRatio1 = 0.0;
10049 double dBrHXXRatio2 = 0.0;
10050 if (fstate==0){
10051 // Use for Cross-section [pb] with no Higgs-boson decay
10052 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10053 } else if (fstate == 1){
10054 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10055 dBrHXXRatio1 = BrHXXRatio - 1.0;
10056 dBrHXXRatio2 = 0.0;
10057 } else if (fstate == 2){
10058 BrHXXRatio = (myNPbase->BrHgagaRatio());
10059 dBrHXXRatio1 = BrHXXRatio - 1.0;
10060 dBrHXXRatio2 = 0.0;
10061 } else if (fstate == 3){
10062 BrHXXRatio = (myNPbase->BrHbbRatio());
10063 dBrHXXRatio1 = BrHXXRatio - 1.0;
10064 dBrHXXRatio2 = 0.0;
10065 } else if (fstate == 4){
10066 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10067 dBrHXXRatio1 = BrHXXRatio - 1.0;
10068 dBrHXXRatio2 = 0.0;
10069 } else if (fstate == 5){
10070 BrHXXRatio = (myNPbase->BrHtautauRatio());
10071 dBrHXXRatio1 = BrHXXRatio - 1.0;
10072 dBrHXXRatio2 = 0.0;
10073 } else {
10074 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10075 }
10076
10077 //-- Production x Decay:
10078 if ((this->getModel()).isModelLinearized()){
10079 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10080 } else if((this->getModel()).isModelNPquadratic()){
10081 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10082 } else {
10083 return weight*(muProd)*(BrHXXRatio);
10084 }
10085
10086}
10087
10088// -----------------------------------------------------------------------------
10089
10090//AG:STXS2024
10091STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10092: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10093{
10094 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10095 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10096
10097}
10098
10100{
10101 //-- Production:
10102 double weight = 1.0; //If normalized to the SM
10104 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10105 double muProd2 = 0.0;
10106
10107 //-- Decay:
10108 double BrHXXRatio = 1.0;
10109 double dBrHXXRatio1 = 0.0;
10110 double dBrHXXRatio2 = 0.0;
10111 if (fstate==0){
10112 // Use for Cross-section [pb] with no Higgs-boson decay
10113 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10114 } else if (fstate == 1){
10115 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10116 dBrHXXRatio1 = BrHXXRatio - 1.0;
10117 dBrHXXRatio2 = 0.0;
10118 } else if (fstate == 2){
10119 BrHXXRatio = (myNPbase->BrHgagaRatio());
10120 dBrHXXRatio1 = BrHXXRatio - 1.0;
10121 dBrHXXRatio2 = 0.0;
10122 } else if (fstate == 3){
10123 BrHXXRatio = (myNPbase->BrHbbRatio());
10124 dBrHXXRatio1 = BrHXXRatio - 1.0;
10125 dBrHXXRatio2 = 0.0;
10126 } else if (fstate == 4){
10127 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10128 dBrHXXRatio1 = BrHXXRatio - 1.0;
10129 dBrHXXRatio2 = 0.0;
10130 } else if (fstate == 5){
10131 BrHXXRatio = (myNPbase->BrHtautauRatio());
10132 dBrHXXRatio1 = BrHXXRatio - 1.0;
10133 dBrHXXRatio2 = 0.0;
10134 } else {
10135 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10136 }
10137
10138 //-- Production x Decay:
10139 if ((this->getModel()).isModelLinearized()){
10140 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10141 } else if((this->getModel()).isModelNPquadratic()){
10142 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10143 } else {
10144 return weight*(muProd)*(BrHXXRatio);
10145 }
10146
10147
10148}
10149
10150// -----------------------------------------------------------------------------
10151
10152STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10153: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10154{
10155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10156 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10157
10158}
10159
10161{
10162 double BrHXXRatio = 1.0;
10163 if (fstate == 1){
10164 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10165 } else if (fstate == 2){
10166 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10167 } else if (fstate == 3){
10168 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10169 } else if (fstate == 4){
10170 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10171 } else {
10172 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10173 }
10174
10175 if ((this->getModel()).isModelLinearized()) {
10176 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10177 } else {
10178 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10179 }
10180}
10181
10182// -----------------------------------------------------------------------------
10183
10184STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10185: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10186{
10187 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10188 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10189
10190}
10191
10193{
10194 double BrHXXRatio = 1.0;
10195 if (fstate == 1){
10196 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10197 } else if (fstate == 2){
10198 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10199 } else if (fstate == 3){
10200 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10201 } else if (fstate == 4){
10202 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10203 } else {
10204 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10205 }
10206
10207 if ((this->getModel()).isModelLinearized()) {
10208 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10209 } else {
10210 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10211 }
10212}
10213
10214// -----------------------------------------------------------------------------
10215
10216//AG:STXS2024
10217STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10218: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10219{
10220 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10221 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10222
10223}
10224
10226{
10227 //-- Production:
10228 double weight = 1.0; //If normalized to the SM
10229 //Since adding bins, include partial weigths of SM_predictions
10230 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10231 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10232 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10233 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10234 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10235 double muProd2 = 0.0;
10236
10237 //-- Decay:
10238 double BrHXXRatio = 1.0;
10239 double dBrHXXRatio1 = 0.0;
10240 double dBrHXXRatio2 = 0.0;
10241 if (fstate==0){
10242 // Use for Cross-section [pb] with no Higgs-boson decay
10243 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10244 } else if (fstate == 1){
10245 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10246 dBrHXXRatio1 = BrHXXRatio - 1.0;
10247 dBrHXXRatio2 = 0.0;
10248 } else if (fstate == 2){
10249 BrHXXRatio = (myNPbase->BrHgagaRatio());
10250 dBrHXXRatio1 = BrHXXRatio - 1.0;
10251 dBrHXXRatio2 = 0.0;
10252 } else if (fstate == 3){
10253 BrHXXRatio = (myNPbase->BrHbbRatio());
10254 dBrHXXRatio1 = BrHXXRatio - 1.0;
10255 dBrHXXRatio2 = 0.0;
10256 } else if (fstate == 4){
10257 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10258 dBrHXXRatio1 = BrHXXRatio - 1.0;
10259 dBrHXXRatio2 = 0.0;
10260 } else {
10261 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10262 }
10263
10264 //-- Production x Decay:
10265 if ((this->getModel()).isModelLinearized()){
10266 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10267 } else if((this->getModel()).isModelNPquadratic()){
10268 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10269 } else {
10270 return weight*(muProd)*(BrHXXRatio);
10271 }
10272
10273
10274}
10275
10276// -----------------------------------------------------------------------------
10277
10278//AG:STXS2024
10279STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10280: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10281{
10282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10283 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10284
10285}
10286
10288{
10289 //-- Production:
10290 double weight = 1.0; //If normalized to the SM
10291 //Since adding bins, include partial weigths of SM_predictions
10292 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10293 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10295 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10296 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10297 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10298 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10299 double muProd2 = 0.0;
10300
10301 //-- Decay:
10302 double BrHXXRatio = 1.0;
10303 double dBrHXXRatio1 = 0.0;
10304 double dBrHXXRatio2 = 0.0;
10305 if (fstate==0){
10306 // Use for Cross-section [pb] with no Higgs-boson decay
10307 weight = 1.0 ;
10308 } else if (fstate == 1){
10309 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10310 dBrHXXRatio1 = BrHXXRatio - 1.0;
10311 dBrHXXRatio2 = 0.0;
10312 } else if (fstate == 2){
10313 BrHXXRatio = (myNPbase->BrHgagaRatio());
10314 dBrHXXRatio1 = BrHXXRatio - 1.0;
10315 dBrHXXRatio2 = 0.0;
10316 } else if (fstate == 3){
10317 BrHXXRatio = (myNPbase->BrHbbRatio());
10318 dBrHXXRatio1 = BrHXXRatio - 1.0;
10319 dBrHXXRatio2 = 0.0;
10320 } else if (fstate == 4){
10321 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10322 dBrHXXRatio1 = BrHXXRatio - 1.0;
10323 dBrHXXRatio2 = 0.0;
10324 } else {
10325 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10326 }
10327
10328 //-- Production x Decay:
10329 if ((this->getModel()).isModelLinearized()){
10330 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10331 } else if((this->getModel()).isModelNPquadratic()){
10332 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10333 } else {
10334 return weight*(muProd)*(BrHXXRatio);
10335 }
10336
10337
10338}
10339
10340// -----------------------------------------------------------------------------
10341
10342//AG:STXS2024
10343STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10344: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10345{
10346 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10347 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10348
10349}
10350
10352{
10353 //-- Production:
10354 double weight = 1.0; //If normalized to the SM
10355 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10356 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10357 double muProd2 = 0.0;
10358
10359 //-- Decay:
10360 double BrHXXRatio = 1.0;
10361 double dBrHXXRatio1 = 0.0;
10362 double dBrHXXRatio2 = 0.0;
10363 if (fstate==0){
10364 // Use for Cross-section [pb] with no Higgs-boson decay
10365 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10366 } else if (fstate == 1){
10367 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10368 dBrHXXRatio1 = BrHXXRatio - 1.0;
10369 dBrHXXRatio2 = 0.0;
10370 } else if (fstate == 2){
10371 BrHXXRatio = (myNPbase->BrHgagaRatio());
10372 dBrHXXRatio1 = BrHXXRatio - 1.0;
10373 dBrHXXRatio2 = 0.0;
10374 } else if (fstate == 3){
10375 BrHXXRatio = (myNPbase->BrHbbRatio());
10376 dBrHXXRatio1 = BrHXXRatio - 1.0;
10377 dBrHXXRatio2 = 0.0;
10378 } else if (fstate == 4){
10379 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10380 dBrHXXRatio1 = BrHXXRatio - 1.0;
10381 dBrHXXRatio2 = 0.0;
10382 } else {
10383 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10384 }
10385
10386 //-- Production x Decay:
10387 if ((this->getModel()).isModelLinearized()){
10388 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10389 } else if((this->getModel()).isModelNPquadratic()){
10390 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10391 } else {
10392 return weight*(muProd)*(BrHXXRatio);
10393 }
10394
10395
10396}
10397
10398// -----------------------------------------------------------------------------
10399
10400//AG:STXS2024
10401STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10402: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10403{
10404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10405 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10406
10407}
10408
10410{
10411 //-- Production:
10412 double weight = 1.0; //If normalized to the SM
10413 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10414 double muProd1 = muProd-1.0 ;
10415 double muProd2 = 0.0;
10416
10417 //-- Decay:
10418 double BrHXXRatio = 1.0;
10419 double dBrHXXRatio1 = 0.0;
10420 double dBrHXXRatio2 = 0.0;
10421 if (fstate==0){
10422 // Use for Cross-section [pb] with no Higgs-boson decay
10423 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10424 } else if (fstate == 1){
10425 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10426 dBrHXXRatio1 = BrHXXRatio - 1.0;
10427 dBrHXXRatio2 = 0.0;
10428 } else if (fstate == 2){
10429 BrHXXRatio = (myNPbase->BrHgagaRatio());
10430 dBrHXXRatio1 = BrHXXRatio - 1.0;
10431 dBrHXXRatio2 = 0.0;
10432 } else if (fstate == 3){
10433 BrHXXRatio = (myNPbase->BrHbbRatio());
10434 dBrHXXRatio1 = BrHXXRatio - 1.0;
10435 dBrHXXRatio2 = 0.0;
10436 } else if (fstate == 4){
10437 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10438 dBrHXXRatio1 = BrHXXRatio - 1.0;
10439 dBrHXXRatio2 = 0.0;
10440 } else {
10441 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10442 }
10443
10444 //-- Production x Decay:
10445 if ((this->getModel()).isModelLinearized()){
10446 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10447 } else if((this->getModel()).isModelNPquadratic()){
10448 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10449 } else {
10450 return weight*(muProd)*(BrHXXRatio);
10451 }
10452
10453
10454}
10455
10456
10457// -----------------------------------------------------------------------------
10458
10459STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10460: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10461{
10462 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10463 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10464
10465}
10466
10468{
10469 double BrHXXRatio = 1.0;
10470 if (fstate == 1){
10471 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10472 } else if (fstate == 2){
10473 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10474 } else if (fstate == 3){
10475 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10476 } else if (fstate == 4){
10477 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10478 } else {
10479 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10480 }
10481
10482 if ((this->getModel()).isModelLinearized()) {
10483 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10484 } else {
10485 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10486 }
10487}
10488
10489// -----------------------------------------------------------------------------
10490
10491//AG:STXS2024
10492STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10493: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10494{
10495 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10496 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10497
10498}
10499
10501{
10502 //-- Production:
10503 double weight = 1.0; //If normalized to the SM
10504 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10505 double muProd1 = muProd -1.0;
10506 double muProd2 = 0.0;
10507
10508 //-- Decay:
10509 double BrHXXRatio = 1.0;
10510 double dBrHXXRatio1 = 0.0;
10511 double dBrHXXRatio2 = 0.0;
10512 if (fstate==0){
10513 // Use for Cross-section [pb] with no Higgs-boson decay
10514 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10515 } else if (fstate == 1){
10516 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10517 dBrHXXRatio1 = BrHXXRatio - 1.0;
10518 dBrHXXRatio2 = 0.0;
10519 } else if (fstate == 2){
10520 BrHXXRatio = (myNPbase->BrHgagaRatio());
10521 dBrHXXRatio1 = BrHXXRatio - 1.0;
10522 dBrHXXRatio2 = 0.0;
10523 } else if (fstate == 3){
10524 BrHXXRatio = (myNPbase->BrHbbRatio());
10525 dBrHXXRatio1 = BrHXXRatio - 1.0;
10526 dBrHXXRatio2 = 0.0;
10527 } else if (fstate == 4){
10528 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10529 dBrHXXRatio1 = BrHXXRatio - 1.0;
10530 dBrHXXRatio2 = 0.0;
10531 } else {
10532 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10533 }
10534
10535 //-- Production x Decay:
10536 if ((this->getModel()).isModelLinearized()){
10537 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10538 } else if((this->getModel()).isModelNPquadratic()){
10539 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10540 } else {
10541 return weight*(muProd)*(BrHXXRatio);
10542 }
10543
10544
10545}
10546
10547// -----------------------------------------------------------------------------
10548
10549//AG:STXS2024
10550STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10551: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10552{
10553 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10554 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10555
10556}
10557
10559{
10560 //-- Production:
10561 double weight = 1.0; //If normalized to the SM
10563 double muProd1 = muProd -1.0;
10564 double muProd2 = 0.0;
10565
10566 //-- Decay:
10567 double BrHXXRatio = 1.0;
10568 double dBrHXXRatio1 = 0.0;
10569 double dBrHXXRatio2 = 0.0;
10570 if (fstate==0){
10571 // Use for Cross-section [pb] with no Higgs-boson decay
10572 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10573 } else if (fstate == 1){
10574 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10575 dBrHXXRatio1 = BrHXXRatio - 1.0;
10576 dBrHXXRatio2 = 0.0;
10577 } else if (fstate == 2){
10578 BrHXXRatio = (myNPbase->BrHgagaRatio());
10579 dBrHXXRatio1 = BrHXXRatio - 1.0;
10580 dBrHXXRatio2 = 0.0;
10581 } else if (fstate == 3){
10582 BrHXXRatio = (myNPbase->BrHbbRatio());
10583 dBrHXXRatio1 = BrHXXRatio - 1.0;
10584 dBrHXXRatio2 = 0.0;
10585 } else if (fstate == 4){
10586 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10587 dBrHXXRatio1 = BrHXXRatio - 1.0;
10588 dBrHXXRatio2 = 0.0;
10589 } else {
10590 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10591 }
10592
10593 //-- Production x Decay:
10594 if ((this->getModel()).isModelLinearized()){
10595 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10596 } else if((this->getModel()).isModelNPquadratic()){
10597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10598 } else {
10599 return weight*(muProd)*(BrHXXRatio);
10600 }
10601
10602}
10603
10604// -----------------------------------------------------------------------------
10605
10606STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10607: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10608{
10609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10610 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10611
10612}
10613
10615{
10616 double BrHXXRatio = 1.0;
10617 if (fstate == 1){
10618 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10619 } else if (fstate == 2){
10620 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10621 } else if (fstate == 3){
10622 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10623 } else if (fstate == 4){
10624 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10625 } else {
10626 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10627 }
10628
10629 if ((this->getModel()).isModelLinearized()) {
10630 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10631 } else {
10632 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10633 }
10634}
10635
10636// -----------------------------------------------------------------------------
10637
10638STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10639: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10640{
10641 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10642 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10643
10644}
10645
10647{
10648 double BrHXXRatio = 1.0;
10649 if (fstate == 1){
10650 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10651 } else if (fstate == 2){
10652 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10653 } else if (fstate == 3){
10654 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10655 } else if (fstate == 4){
10656 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10657 } else {
10658 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10659 }
10660
10661 if ((this->getModel()).isModelLinearized()) {
10662 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10663 } else {
10664 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10665 }
10666}
10667
10668
10669// -----------------------------------------------------------------------------
10670
10671//AG:STXS2024
10672STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10673: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10674{
10675 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10676 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10677
10678}
10679
10681{
10682 //-- Production:
10683 double weight = 1.0; //If normalized to the SM
10684 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10685 double muProd1 = muProd -1.0;
10686 double muProd2 = 0.0;
10687
10688 //-- Decay:
10689 double BrHXXRatio = 1.0;
10690 double dBrHXXRatio1 = 0.0;
10691 double dBrHXXRatio2 = 0.0;
10692 if (fstate==0){
10693 // Use for Cross-section [pb] with no Higgs-boson decay
10694 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10695 } else if (fstate == 1){
10696 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10697 dBrHXXRatio1 = BrHXXRatio - 1.0;
10698 dBrHXXRatio2 = 0.0;
10699 } else if (fstate == 2){
10700 BrHXXRatio = (myNPbase->BrHgagaRatio());
10701 dBrHXXRatio1 = BrHXXRatio - 1.0;
10702 dBrHXXRatio2 = 0.0;
10703 } else if (fstate == 3){
10704 BrHXXRatio = (myNPbase->BrHbbRatio());
10705 dBrHXXRatio1 = BrHXXRatio - 1.0;
10706 dBrHXXRatio2 = 0.0;
10707 } else if (fstate == 4){
10708 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10709 dBrHXXRatio1 = BrHXXRatio - 1.0;
10710 dBrHXXRatio2 = 0.0;
10711 } else {
10712 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10713 }
10714
10715 //-- Production x Decay:
10716 if ((this->getModel()).isModelLinearized()){
10717 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10718 } else if((this->getModel()).isModelNPquadratic()){
10719 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10720 } else {
10721 return weight*(muProd)*(BrHXXRatio);
10722 }
10723
10724}
10725
10726// -----------------------------------------------------------------------------
10727
10728//AG:STXS2024
10729STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10730: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10731{
10732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10733 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10734
10735}
10736
10738{
10739 //-- Production:
10740 double weight = 1.0; //If normalized to the SM
10741 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10742 double muProd1 = muProd -1.0;
10743 double muProd2 = 0.0;
10744
10745 //-- Decay:
10746 double BrHXXRatio = 1.0;
10747 double dBrHXXRatio1 = 0.0;
10748 double dBrHXXRatio2 = 0.0;
10749 if (fstate==0){
10750 // Use for Cross-section [pb] with no Higgs-boson decay
10751 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10752 } else if (fstate == 1){
10753 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10754 dBrHXXRatio1 = BrHXXRatio - 1.0;
10755 dBrHXXRatio2 = 0.0;
10756 } else if (fstate == 2){
10757 BrHXXRatio = (myNPbase->BrHgagaRatio());
10758 dBrHXXRatio1 = BrHXXRatio - 1.0;
10759 dBrHXXRatio2 = 0.0;
10760 } else if (fstate == 3){
10761 BrHXXRatio = (myNPbase->BrHbbRatio());
10762 dBrHXXRatio1 = BrHXXRatio - 1.0;
10763 dBrHXXRatio2 = 0.0;
10764 } else if (fstate == 4){
10765 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10766 dBrHXXRatio1 = BrHXXRatio - 1.0;
10767 dBrHXXRatio2 = 0.0;
10768 } else {
10769 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10770 }
10771
10772 //-- Production x Decay:
10773 if ((this->getModel()).isModelLinearized()){
10774 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10775 } else if((this->getModel()).isModelNPquadratic()){
10776 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10777 } else {
10778 return weight*(muProd)*(BrHXXRatio);
10779 }
10780
10781}
10782
10783// -----------------------------------------------------------------------------
10784
10785//AG:STXS2024
10786STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10787: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10788{
10789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10790 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10791
10792}
10793
10795{
10796 //-- Production:
10797 double weight = 1.0; //If normalized to the SM
10798 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10799 double muProd1 = muProd -1.0;
10800 double muProd2 = 0.0;
10801
10802 //-- Decay:
10803 double BrHXXRatio = 1.0;
10804 double dBrHXXRatio1 = 0.0;
10805 double dBrHXXRatio2 = 0.0;
10806 if (fstate==0){
10807 // Use for Cross-section [pb] with no Higgs-boson decay
10808 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10809 } else if (fstate == 1){
10810 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10811 dBrHXXRatio1 = BrHXXRatio - 1.0;
10812 dBrHXXRatio2 = 0.0;
10813 } else if (fstate == 2){
10814 BrHXXRatio = (myNPbase->BrHgagaRatio());
10815 dBrHXXRatio1 = BrHXXRatio - 1.0;
10816 dBrHXXRatio2 = 0.0;
10817 } else if (fstate == 3){
10818 BrHXXRatio = (myNPbase->BrHbbRatio());
10819 dBrHXXRatio1 = BrHXXRatio - 1.0;
10820 dBrHXXRatio2 = 0.0;
10821 } else if (fstate == 4){
10822 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10823 dBrHXXRatio1 = BrHXXRatio - 1.0;
10824 dBrHXXRatio2 = 0.0;
10825 } else {
10826 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10827 }
10828
10829 //-- Production x Decay:
10830 if ((this->getModel()).isModelLinearized()){
10831 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10832 } else if((this->getModel()).isModelNPquadratic()){
10833 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10834 } else {
10835 return weight*(muProd)*(BrHXXRatio);
10836 }
10837
10838
10839}
10840
10841// -----------------------------------------------------------------------------
10842
10843//AG:STXS2024
10844STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10845: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10846{
10847 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10848 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10849
10850}
10851
10853{
10854 //-- Production:
10855 double weight = 1.0; //If normalized to the SM
10856 //Since adding bins, include partial weigths of SM_predictions
10857 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10858 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10860 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10861 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10862 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10863 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10864 double muProd2 = 0.0;
10865
10866 //-- Decay:
10867 double BrHXXRatio = 1.0;
10868 double dBrHXXRatio1 = 0.0;
10869 double dBrHXXRatio2 = 0.0;
10870 if (fstate==0){
10871 weight = 1.0 ;
10872 } else if (fstate == 1){
10873 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10874 dBrHXXRatio1 = BrHXXRatio - 1.0;
10875 dBrHXXRatio2 = 0.0;
10876 } else if (fstate == 2){
10877 BrHXXRatio = (myNPbase->BrHgagaRatio());
10878 dBrHXXRatio1 = BrHXXRatio - 1.0;
10879 dBrHXXRatio2 = 0.0;
10880 } else if (fstate == 3){
10881 BrHXXRatio = (myNPbase->BrHbbRatio());
10882 dBrHXXRatio1 = BrHXXRatio - 1.0;
10883 dBrHXXRatio2 = 0.0;
10884 } else if (fstate == 4){
10885 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10886 dBrHXXRatio1 = BrHXXRatio - 1.0;
10887 dBrHXXRatio2 = 0.0;
10888 } else {
10889 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10890 }
10891
10892 //-- Production x Decay:
10893 if ((this->getModel()).isModelLinearized()){
10894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10895 } else if((this->getModel()).isModelNPquadratic()){
10896 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10897 } else {
10898 return weight*(muProd)*(BrHXXRatio);
10899 }
10900
10901
10902}
10903
10904// -----------------------------------------------------------------------------
10905
10906//AG:STXS2024
10907STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10908: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10909{
10910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10911 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10912
10913}
10914
10916{
10917 //-- Production:
10918 double weight = 1.0; //If normalized to the SM
10919 //Since adding bins, include partial weigths of SM_predictions
10920 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10921 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10930 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10931 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10932 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10934 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10935 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10936 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10938 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10939 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10940 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10941 double muProd2 = 0.0;
10942
10943 //-- Decay:
10944 double BrHXXRatio = 1.0;
10945 double dBrHXXRatio1 = 0.0;
10946 double dBrHXXRatio2 = 0.0;
10947 if (fstate==0){
10948 weight = 1.0;
10949 } else if (fstate == 1){
10950 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10951 dBrHXXRatio1 = BrHXXRatio - 1.0;
10952 dBrHXXRatio2 = 0.0;
10953 } else if (fstate == 2){
10954 BrHXXRatio = (myNPbase->BrHgagaRatio());
10955 dBrHXXRatio1 = BrHXXRatio - 1.0;
10956 dBrHXXRatio2 = 0.0;
10957 } else if (fstate == 3){
10958 BrHXXRatio = (myNPbase->BrHbbRatio());
10959 dBrHXXRatio1 = BrHXXRatio - 1.0;
10960 dBrHXXRatio2 = 0.0;
10961 } else if (fstate == 4){
10962 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10963 dBrHXXRatio1 = BrHXXRatio - 1.0;
10964 dBrHXXRatio2 = 0.0;
10965 } else if (fstate == 5){
10966 BrHXXRatio = (myNPbase->BrHtautauRatio());
10967 dBrHXXRatio1 = BrHXXRatio - 1.0;
10968 dBrHXXRatio2 = 0.0;
10969 } else if (fstate == 6){
10970 BrHXXRatio = (myNPbase->BrHWWRatio());
10971 dBrHXXRatio1 = BrHXXRatio - 1.0;
10972 dBrHXXRatio2 = 0.0;
10973 } else if (fstate == 7){
10974 BrHXXRatio = (myNPbase->BrHZZRatio());
10975 dBrHXXRatio1 = BrHXXRatio - 1.0;
10976 dBrHXXRatio2 = 0.0;
10977 } else {
10978 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10979 }
10980
10981 //-- Production x Decay:
10982 if ((this->getModel()).isModelLinearized()){
10983 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10984 } else if((this->getModel()).isModelNPquadratic()){
10985 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10986 } else {
10987 return weight*(muProd)*(BrHXXRatio);
10988 }
10989
10990
10991}
10992
10993// -----------------------------------------------------------------------------
10994
10995//AG:STXS2024
10996STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10997: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10998{
10999 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11000 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
11001
11002}
11003
11005{
11006 //-- Production:
11007 double weight = 1.0; //If normalized to the SM
11008 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
11009 double muProd1 = muProd -1.0;
11010 double muProd2 = 0.0;
11011
11012 //-- Decay:
11013 double BrHXXRatio = 1.0;
11014 double dBrHXXRatio1 = 0.0;
11015 double dBrHXXRatio2 = 0.0;
11016 if (fstate==0){
11017 // Use for Cross-section [pb] with no Higgs-boson decay
11018 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11019 } else if (fstate == 1){
11020 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11021 dBrHXXRatio1 = BrHXXRatio - 1.0;
11022 dBrHXXRatio2 = 0.0;
11023 } else if (fstate == 2){
11024 BrHXXRatio = (myNPbase->BrHgagaRatio());
11025 dBrHXXRatio1 = BrHXXRatio - 1.0;
11026 dBrHXXRatio2 = 0.0;
11027 } else if (fstate == 3){
11028 BrHXXRatio = (myNPbase->BrHbbRatio());
11029 dBrHXXRatio1 = BrHXXRatio - 1.0;
11030 dBrHXXRatio2 = 0.0;
11031 } else if (fstate == 4){
11032 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11033 dBrHXXRatio1 = BrHXXRatio - 1.0;
11034 dBrHXXRatio2 = 0.0;
11035 } else {
11036 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
11037 }
11038
11039 //-- Production x Decay:
11040 if ((this->getModel()).isModelLinearized()){
11041 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11042 } else if((this->getModel()).isModelNPquadratic()){
11043 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11044 } else {
11045 return weight*(muProd)*(BrHXXRatio);
11046 }
11047
11048
11049}
11050
11051// -----------------------------------------------------------------------------
11052
11053//AG:STXS2024
11054STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11055: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11056{
11057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11058 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
11059
11060}
11061
11063{
11064 //-- Production:
11065 double weight = 1.0; //If normalized to the SM
11066 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
11067 double muProd1 = muProd -1.0;
11068 double muProd2 = 0.0;
11069
11070 //-- Decay:
11071 double BrHXXRatio = 1.0;
11072 double dBrHXXRatio1 = 0.0;
11073 double dBrHXXRatio2 = 0.0;
11074 if (fstate==0){
11075 // Use for Cross-section [pb] with no Higgs-boson decay
11076 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11077 } else if (fstate == 1){
11078 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11079 dBrHXXRatio1 = BrHXXRatio - 1.0;
11080 dBrHXXRatio2 = 0.0;
11081 } else if (fstate == 2){
11082 BrHXXRatio = (myNPbase->BrHgagaRatio());
11083 dBrHXXRatio1 = BrHXXRatio - 1.0;
11084 dBrHXXRatio2 = 0.0;
11085 } else if (fstate == 3){
11086 BrHXXRatio = (myNPbase->BrHbbRatio());
11087 dBrHXXRatio1 = BrHXXRatio - 1.0;
11088 dBrHXXRatio2 = 0.0;
11089 } else if (fstate == 4){
11090 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11091 dBrHXXRatio1 = BrHXXRatio - 1.0;
11092 dBrHXXRatio2 = 0.0;
11093 } else {
11094 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11095 }
11096
11097 //-- Production x Decay:
11098 if ((this->getModel()).isModelLinearized()){
11099 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11100 } else if((this->getModel()).isModelNPquadratic()){
11101 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11102 } else {
11103 return weight*(muProd)*(BrHXXRatio);
11104 }
11105
11106}
11107
11108// -----------------------------------------------------------------------------
11109
11110//AG:STXS2024
11111STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11112: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11113{
11114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11115 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11116
11117}
11118
11120{
11121 //-- Production:
11122 double weight = 1.0; //If normalized to the SM
11123 //Since adding bins, include partial weigths of SM_predictions
11124 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11125 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11126 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11127 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11128 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11129 double muProd2 = 0.0;
11130
11131 //-- Decay:
11132 double BrHXXRatio = 1.0;
11133 double dBrHXXRatio1 = 0.0;
11134 double dBrHXXRatio2 = 0.0;
11135 if (fstate==0){
11136 // Use for Cross-section [pb] with no Higgs-boson decay
11137 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11138 } else if (fstate == 1){
11139 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11140 dBrHXXRatio1 = BrHXXRatio - 1.0;
11141 dBrHXXRatio2 = 0.0;
11142 } else if (fstate == 2){
11143 BrHXXRatio = (myNPbase->BrHgagaRatio());
11144 dBrHXXRatio1 = BrHXXRatio - 1.0;
11145 dBrHXXRatio2 = 0.0;
11146 } else if (fstate == 3){
11147 BrHXXRatio = (myNPbase->BrHbbRatio());
11148 dBrHXXRatio1 = BrHXXRatio - 1.0;
11149 dBrHXXRatio2 = 0.0;
11150 } else if (fstate == 4){
11151 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11152 dBrHXXRatio1 = BrHXXRatio - 1.0;
11153 dBrHXXRatio2 = 0.0;
11154 } else {
11155 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11156 }
11157
11158 //-- Production x Decay:
11159 if ((this->getModel()).isModelLinearized()){
11160 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11161 } else if((this->getModel()).isModelNPquadratic()){
11162 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11163 } else {
11164 return weight*(muProd)*(BrHXXRatio);
11165 }
11166
11167}
11168
11169// -----------------------------------------------------------------------------
11170
11171//AG:STXS2024
11172STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11173: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11174{
11175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11176 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11177
11178}
11179
11181{
11182 //-- Production:
11183 double weight = 1.0; //If normalized to the SM
11184 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11185 double muProd1 = muProd -1.0;
11186 double muProd2 = 0.0;
11187
11188 //-- Decay:
11189 double BrHXXRatio = 1.0;
11190 double dBrHXXRatio1 = 0.0;
11191 double dBrHXXRatio2 = 0.0;
11192 if (fstate==0){
11193 // Use for Cross-section [pb] with no Higgs-boson decay
11194 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11195 } else if (fstate == 1){
11196 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11197 dBrHXXRatio1 = BrHXXRatio - 1.0;
11198 dBrHXXRatio2 = 0.0;
11199 } else if (fstate == 2){
11200 BrHXXRatio = (myNPbase->BrHgagaRatio());
11201 dBrHXXRatio1 = BrHXXRatio - 1.0;
11202 dBrHXXRatio2 = 0.0;
11203 } else if (fstate == 3){
11204 BrHXXRatio = (myNPbase->BrHbbRatio());
11205 dBrHXXRatio1 = BrHXXRatio - 1.0;
11206 dBrHXXRatio2 = 0.0;
11207 } else if (fstate == 4){
11208 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11209 dBrHXXRatio1 = BrHXXRatio - 1.0;
11210 dBrHXXRatio2 = 0.0;
11211 } else {
11212 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11213 }
11214
11215 //-- Production x Decay:
11216 if ((this->getModel()).isModelLinearized()){
11217 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11218 } else if((this->getModel()).isModelNPquadratic()){
11219 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11220 } else {
11221 return weight*(muProd)*(BrHXXRatio);
11222 }
11223
11224}
11225
11226// -----------------------------------------------------------------------------
11227
11228//AG:STXS2024
11229STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11230: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11231{
11232 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11233 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11234
11235}
11236
11238{
11239 //-- Production:
11240 double weight = 1.0; //If normalized to the SM
11241 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11242 double muProd1 = muProd -1.0;
11243 double muProd2 = 0.0;
11244
11245 //-- Decay:
11246 double BrHXXRatio = 1.0;
11247 double dBrHXXRatio1 = 0.0;
11248 double dBrHXXRatio2 = 0.0;
11249 if (fstate==0){
11250 // Use for Cross-section [pb] with no Higgs-boson decay
11251 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11252 } else if (fstate == 1){
11253 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11254 dBrHXXRatio1 = BrHXXRatio - 1.0;
11255 dBrHXXRatio2 = 0.0;
11256 } else if (fstate == 2){
11257 BrHXXRatio = (myNPbase->BrHgagaRatio());
11258 dBrHXXRatio1 = BrHXXRatio - 1.0;
11259 dBrHXXRatio2 = 0.0;
11260 } else if (fstate == 3){
11261 BrHXXRatio = (myNPbase->BrHbbRatio());
11262 dBrHXXRatio1 = BrHXXRatio - 1.0;
11263 dBrHXXRatio2 = 0.0;
11264 } else if (fstate == 4){
11265 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11266 dBrHXXRatio1 = BrHXXRatio - 1.0;
11267 dBrHXXRatio2 = 0.0;
11268 } else {
11269 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11270 }
11271
11272 //-- Production x Decay:
11273 if ((this->getModel()).isModelLinearized()){
11274 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11275 } else if((this->getModel()).isModelNPquadratic()){
11276 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11277 } else {
11278 return weight*(muProd)*(BrHXXRatio);
11279 }
11280
11281}
11282
11283// -----------------------------------------------------------------------------
11284
11285STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11286: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11287{
11288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11289 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11290
11291}
11292
11294{
11295 //-- Production:
11296 double weight = 1.0; //If normalized to the SM
11297 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11298 double muProd1 = muProd -1.0;
11299 double muProd2 = 0.0;
11300
11301 //-- Decay:
11302 double BrHXXRatio = 1.0;
11303 double dBrHXXRatio1 = 0.0;
11304 double dBrHXXRatio2 = 0.0;
11305 if (fstate==0){
11306 // Use for Cross-section [pb] with no Higgs-boson decay
11307 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11308 } else if (fstate == 1){
11309 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11310 dBrHXXRatio1 = BrHXXRatio - 1.0;
11311 dBrHXXRatio2 = 0.0;
11312 } else if (fstate == 2){
11313 BrHXXRatio = (myNPbase->BrHgagaRatio());
11314 dBrHXXRatio1 = BrHXXRatio - 1.0;
11315 dBrHXXRatio2 = 0.0;
11316 } else if (fstate == 3){
11317 BrHXXRatio = (myNPbase->BrHbbRatio());
11318 dBrHXXRatio1 = BrHXXRatio - 1.0;
11319 dBrHXXRatio2 = 0.0;
11320 } else if (fstate == 4){
11321 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11322 dBrHXXRatio1 = BrHXXRatio - 1.0;
11323 dBrHXXRatio2 = 0.0;
11324 } else {
11325 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11326 }
11327
11328 //-- Production x Decay:
11329 if ((this->getModel()).isModelLinearized()){
11330 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11331 } else if((this->getModel()).isModelNPquadratic()){
11332 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11333 } else {
11334 return weight*(muProd)*(BrHXXRatio);
11335 }
11336
11337
11338}
11339
11340// -----------------------------------------------------------------------------
11341
11342//AG:STXS2024
11343STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11344: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11345{
11346 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11347 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11348
11349}
11350
11352{
11353 //-- Production:
11354 double weight = 1.0; //If normalized to the SM
11355 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11356 double muProd1 = muProd -1.0;
11357 double muProd2 = 0.0;
11358
11359 //-- Decay:
11360 double BrHXXRatio = 1.0;
11361 double dBrHXXRatio1 = 0.0;
11362 double dBrHXXRatio2 = 0.0;
11363 if (fstate==0){
11364 // Use for Cross-section [pb] with no Higgs-boson decay
11365 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11366 } else if (fstate == 1){
11367 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11368 dBrHXXRatio1 = BrHXXRatio - 1.0;
11369 dBrHXXRatio2 = 0.0;
11370 } else if (fstate == 2){
11371 BrHXXRatio = (myNPbase->BrHgagaRatio());
11372 dBrHXXRatio1 = BrHXXRatio - 1.0;
11373 dBrHXXRatio2 = 0.0;
11374 } else if (fstate == 3){
11375 BrHXXRatio = (myNPbase->BrHbbRatio());
11376 dBrHXXRatio1 = BrHXXRatio - 1.0;
11377 dBrHXXRatio2 = 0.0;
11378 } else if (fstate == 4){
11379 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11380 dBrHXXRatio1 = BrHXXRatio - 1.0;
11381 dBrHXXRatio2 = 0.0;
11382 } else if (fstate == 5){
11383 BrHXXRatio = (myNPbase->BrHtautauRatio());
11384 dBrHXXRatio1 = BrHXXRatio - 1.0;
11385 dBrHXXRatio2 = 0.0;
11386 } else {
11387 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11388 }
11389
11390 //-- Production x Decay:
11391 if ((this->getModel()).isModelLinearized()){
11392 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11393 } else if((this->getModel()).isModelNPquadratic()){
11394 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11395 } else {
11396 return weight*(muProd)*(BrHXXRatio);
11397 }
11398
11399}
11400// -----------------------------------------------------------------------------
11401
11402//AG:STXS2024
11403STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11404: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11405{
11406 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11407 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11408
11409}
11410
11412{
11413 //-- Production:
11414 double weight = 1.0; //If normalized to the SM
11415 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11416 double muProd1 = muProd -1.0;
11417 double muProd2 = 0.0;
11418
11419 //-- Decay:
11420 double BrHXXRatio = 1.0;
11421 double dBrHXXRatio1 = 0.0;
11422 double dBrHXXRatio2 = 0.0;
11423 if (fstate==0){
11424 // Use for Cross-section [pb] with no Higgs-boson decay
11425 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11426 } else if (fstate == 1){
11427 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11428 dBrHXXRatio1 = BrHXXRatio - 1.0;
11429 dBrHXXRatio2 = 0.0;
11430 } else if (fstate == 2){
11431 BrHXXRatio = (myNPbase->BrHgagaRatio());
11432 dBrHXXRatio1 = BrHXXRatio - 1.0;
11433 dBrHXXRatio2 = 0.0;
11434 } else if (fstate == 3){
11435 BrHXXRatio = (myNPbase->BrHbbRatio());
11436 dBrHXXRatio1 = BrHXXRatio - 1.0;
11437 dBrHXXRatio2 = 0.0;
11438 } else if (fstate == 4){
11439 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11440 dBrHXXRatio1 = BrHXXRatio - 1.0;
11441 dBrHXXRatio2 = 0.0;
11442 } else if (fstate == 5){
11443 BrHXXRatio = (myNPbase->BrHtautauRatio());
11444 dBrHXXRatio1 = BrHXXRatio - 1.0;
11445 dBrHXXRatio2 = 0.0;
11446 } else {
11447 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11448 }
11449
11450 //-- Production x Decay:
11451 if ((this->getModel()).isModelLinearized()){
11452 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11453 } else if((this->getModel()).isModelNPquadratic()){
11454 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11455 } else {
11456 return weight*(muProd)*(BrHXXRatio);
11457 }
11458
11459}
11460
11461// -----------------------------------------------------------------------------
11462
11463//AG:STXS2024
11464STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11465: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11466{
11467 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11468 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11469
11470}
11471
11473{
11474 //-- Production:
11475 double weight = 1.0; //If normalized to the SM
11476 //Since adding bins, include partial weigths of SM_predictions
11477 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11478 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11479 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11480 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11481 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11482 double muProd2 = 0.0;
11483
11484 //-- Decay:
11485 double BrHXXRatio = 1.0;
11486 double dBrHXXRatio1 = 0.0;
11487 double dBrHXXRatio2 = 0.0;
11488 if (fstate==0){
11489 // Use for Cross-section [pb] with no Higgs-boson decay
11490 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11491 } else if (fstate == 1){
11492 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11493 dBrHXXRatio1 = BrHXXRatio - 1.0;
11494 dBrHXXRatio2 = 0.0;
11495 } else if (fstate == 2){
11496 BrHXXRatio = (myNPbase->BrHgagaRatio());
11497 dBrHXXRatio1 = BrHXXRatio - 1.0;
11498 dBrHXXRatio2 = 0.0;
11499 } else if (fstate == 3){
11500 BrHXXRatio = (myNPbase->BrHbbRatio());
11501 dBrHXXRatio1 = BrHXXRatio - 1.0;
11502 dBrHXXRatio2 = 0.0;
11503 } else if (fstate == 4){
11504 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11505 dBrHXXRatio1 = BrHXXRatio - 1.0;
11506 dBrHXXRatio2 = 0.0;
11507 } else if (fstate == 5){
11508 BrHXXRatio = (myNPbase->BrHtautauRatio());
11509 dBrHXXRatio1 = BrHXXRatio - 1.0;
11510 dBrHXXRatio2 = 0.0;
11511 } else {
11512 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11513 }
11514
11515 //-- Production x Decay:
11516 if ((this->getModel()).isModelLinearized()){
11517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11518 } else if((this->getModel()).isModelNPquadratic()){
11519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11520 } else {
11521 return weight*(muProd)*(BrHXXRatio);
11522 }
11523
11524}
11525
11526// -----------------------------------------------------------------------------
11527
11528//AG:STXS2024
11529STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11530: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11531{
11532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11533 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11534
11535}
11536
11538{
11539 //-- Production:
11540 double weight = 1.0; //If normalized to the SM
11541 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11542 //Since adding bins, include partial weigths (SM_predictions)
11543 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11548 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11549 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11550 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11551 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11552 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11553 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11554 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11555 double muProd2 = 0.0;
11556
11557 //-- Decay:
11558 double BrHXXRatio = 1.0;
11559 double dBrHXXRatio1 = 0.0;
11560 double dBrHXXRatio2 = 0.0;
11561 if (fstate==0){
11562 weight = 1.0;
11563 } else if (fstate == 1){
11564 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11565 dBrHXXRatio1 = BrHXXRatio - 1.0;
11566 dBrHXXRatio2 = 0.0;
11567 } else if (fstate == 2){
11568 BrHXXRatio = (myNPbase->BrHgagaRatio());
11569 dBrHXXRatio1 = BrHXXRatio - 1.0;
11570 dBrHXXRatio2 = 0.0;
11571 } else if (fstate == 3){
11572 BrHXXRatio = (myNPbase->BrHbbRatio());
11573 dBrHXXRatio1 = BrHXXRatio - 1.0;
11574 dBrHXXRatio2 = 0.0;
11575 } else if (fstate == 4){
11576 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11577 dBrHXXRatio1 = BrHXXRatio - 1.0;
11578 dBrHXXRatio2 = 0.0;
11579 } else if (fstate == 5){
11580 BrHXXRatio = (myNPbase->BrHtautauRatio());
11581 dBrHXXRatio1 = BrHXXRatio - 1.0;
11582 dBrHXXRatio2 = 0.0;
11583 } else if (fstate == 6){
11584 BrHXXRatio = (myNPbase->BrHWWRatio());
11585 dBrHXXRatio1 = BrHXXRatio - 1.0;
11586 dBrHXXRatio2 = 0.0;
11587 } else if (fstate == 7){
11588 BrHXXRatio = (myNPbase->BrHZZRatio());
11589 dBrHXXRatio1 = BrHXXRatio - 1.0;
11590 dBrHXXRatio2 = 0.0;
11591 } else {
11592 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11593 }
11594
11595 //-- Production x Decay:
11596 if ((this->getModel()).isModelLinearized()){
11597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11598 } else if((this->getModel()).isModelNPquadratic()){
11599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11600 } else {
11601 return weight*(muProd)*(BrHXXRatio);
11602 }
11603
11604}
11605
11606// -----------------------------------------------------------------------------
11607
11608//AG:STXS2024
11609STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11610: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11611{
11612 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11613 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11614
11615}
11616
11617double STXS12_tH::computeThValue() //AG:modified
11618{
11619 //-- Production:
11620 double weight = 1.0; //If normalized to the SM
11621 double muProd = myNPbase->STXS12_tH(sqrt_s);
11622 double muProd1 = muProd -1.0;
11623 double muProd2 = 0.0;
11624
11625 //-- Decay:
11626 double BrHXXRatio = 1.0;
11627 double dBrHXXRatio1 = 0.0;
11628 double dBrHXXRatio2 = 0.0;
11629 if (fstate==0){
11630 // Use for Cross-section [pb] with no Higgs-boson decay
11631 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11632 } else if (fstate == 1){
11633 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11634 dBrHXXRatio1 = BrHXXRatio - 1.0;
11635 dBrHXXRatio2 = 0.0;
11636 } else if (fstate == 2){
11637 BrHXXRatio = (myNPbase->BrHgagaRatio());
11638 dBrHXXRatio1 = BrHXXRatio - 1.0;
11639 dBrHXXRatio2 = 0.0;
11640 } else if (fstate == 3){
11641 BrHXXRatio = (myNPbase->BrHbbRatio());
11642 dBrHXXRatio1 = BrHXXRatio - 1.0;
11643 dBrHXXRatio2 = 0.0;
11644 } else if (fstate == 4){
11645 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11646 dBrHXXRatio1 = BrHXXRatio - 1.0;
11647 dBrHXXRatio2 = 0.0;
11648 } else if (fstate == 5){
11649 BrHXXRatio = (myNPbase->BrHtautauRatio());
11650 dBrHXXRatio1 = BrHXXRatio - 1.0;
11651 dBrHXXRatio2 = 0.0;
11652 } else {
11653 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11654 }
11655
11656 //-- Production x Decay:
11657 if ((this->getModel()).isModelLinearized()){
11658 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11659 } else if((this->getModel()).isModelNPquadratic()){
11660 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11661 } else {
11662 return weight*(muProd)*(BrHXXRatio);
11663 }
11664
11665
11666}
11667
11668// -----------------------------------------------------------------------------
11669
11670
11671//-----------------------------------------------------------------------------------------
11672//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11673//-----------------------------------------------------------------------------------------
11674
11675
11676muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11677: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11678{
11679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11680 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11681}
11682
11684{
11685 return myNPbase->muTHUggHgaga(sqrt_s);
11686}
11687
11688
11689muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11690: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11691{
11692 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11693 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11694}
11695
11697{
11698 return myNPbase->muTHUVBFHgaga(sqrt_s);
11699}
11700
11701muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11702: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11703{
11704 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11705 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11706}
11707
11709{
11710 return myNPbase->muTHUZHgaga(sqrt_s);
11711}
11712
11713muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11714: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11715{
11716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11717 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11718}
11719
11721{
11722 return myNPbase->muTHUWHgaga(sqrt_s);
11723}
11724
11725muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11726: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11727{
11728 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11729 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11730}
11731
11733{
11734 return myNPbase->muTHUVHgaga(sqrt_s);
11735}
11736
11737muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11738: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11739{
11740 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11741 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11742}
11743
11745{
11746 return myNPbase->muTHUttHgaga(sqrt_s);
11747}
11748
11749muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11750: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11751{
11752 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11753 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11754}
11755
11757{
11758 return myNPbase->muTHUggHZga(sqrt_s);
11759}
11760
11761muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11763{
11764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11765 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11766}
11767
11769{
11770 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11771}
11772
11773muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11774: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11775{
11776 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11777 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11778}
11779
11781{
11782
11783 return myNPbase->muTHUVBFHZga(sqrt_s);
11784}
11785
11786muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11787: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11788{
11789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11790 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11791}
11792
11794{
11795 return myNPbase->muTHUZHZga(sqrt_s);
11796}
11797
11798muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11800{
11801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11802 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11803}
11804
11806{
11807 return myNPbase->muTHUWHZga(sqrt_s);
11808}
11809
11810muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11811: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11812{
11813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11814 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11815}
11816
11818{
11819 return myNPbase->muTHUVHZga(sqrt_s);
11820}
11821
11822muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11823: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11824{
11825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11826 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11827}
11828
11830{
11831 return myNPbase->muTHUttHZga(sqrt_s);
11832}
11833
11834muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11835: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11836{
11837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11838 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11839}
11840
11842{
11843 return myNPbase->muTHUggHZZ(sqrt_s);
11844}
11845
11846muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11848{
11849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11850 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11851}
11852
11854{
11855 return myNPbase->muTHUVBFHZZ(sqrt_s);
11856}
11857
11858muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11859: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11860{
11861 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11862 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11863}
11864
11866{
11867 return myNPbase->muTHUZHZZ(sqrt_s);
11868}
11869
11870muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11872{
11873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11874 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11875}
11876
11878{
11879 return myNPbase->muTHUWHZZ(sqrt_s);
11880}
11881
11882muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11884{
11885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11886 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11887}
11888
11890{
11891 return myNPbase->muTHUVHZZ(sqrt_s);
11892}
11893
11894muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11895: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11896{
11897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11898 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11899}
11900
11902{
11903 return myNPbase->muTHUttHZZ(sqrt_s);
11904}
11905
11906muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11907: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11908{
11909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11910 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11911}
11912
11914{
11915 return myNPbase->muTHUggHZZ4l(sqrt_s);
11916}
11917
11918muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11920{
11921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11922 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11923}
11924
11926{
11927 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11928}
11929
11930muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11932{
11933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11934 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11935}
11936
11938{
11939 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11940}
11941
11942muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11943: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11944{
11945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11946 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11947}
11948
11950{
11951 return myNPbase->muTHUZHZZ4l(sqrt_s);
11952}
11953
11954muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11956{
11957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11958 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11959}
11960
11962{
11963 return myNPbase->muTHUWHZZ4l(sqrt_s);
11964}
11965
11966muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11968{
11969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11970 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11971}
11972
11974{
11975 return myNPbase->muTHUVHZZ4l(sqrt_s);
11976}
11977
11978muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11979: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11980{
11981 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11982 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11983}
11984
11986{
11987 return myNPbase->muTHUttHZZ4l(sqrt_s);
11988}
11989
11990muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11991: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11992{
11993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11994 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11995}
11996
11998{
11999 return myNPbase->muTHUggHWW(sqrt_s);
12000}
12001
12002muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
12003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12004{
12005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12006 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
12007}
12008
12010{
12011 return myNPbase->muTHUVBFHWW(sqrt_s);
12012}
12013
12014muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
12015: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12016{
12017 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12018 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
12019}
12020
12022{
12023 return myNPbase->muTHUZHWW(sqrt_s);
12024}
12025
12026muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
12027: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12028{
12029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12030 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
12031}
12032
12034{
12035 return myNPbase->muTHUWHWW(sqrt_s);
12036}
12037
12038muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
12039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12040{
12041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12042 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
12043}
12044
12046{
12047 return myNPbase->muTHUVHWW(sqrt_s);
12048}
12049
12050muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
12051: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12052{
12053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12054 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
12055}
12056
12058{
12059 return myNPbase->muTHUttHWW(sqrt_s);
12060}
12061
12062muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12063: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12064{
12065 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12066 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
12067}
12068
12070{
12072}
12073
12074muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12076{
12077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12078 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12079}
12080
12082{
12084}
12085
12086muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12088{
12089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12090 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12091}
12092
12094{
12095 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12096}
12097
12098muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12099: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12100{
12101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12102 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12103}
12104
12106{
12107 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12108}
12109
12110muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12112{
12113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12114 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12115}
12116
12118{
12119 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12120}
12121
12122muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12123: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12124{
12125 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12126 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12127}
12128
12130{
12132}
12133
12134muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12136{
12137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12138 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12139}
12140
12142{
12143 return myNPbase->muTHUggHmumu(sqrt_s);
12144}
12145
12146muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12147: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12148{
12149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12150 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12151}
12152
12154{
12155 return myNPbase->muTHUVBFHmumu(sqrt_s);
12156}
12157
12158muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12159: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12160{
12161 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12162 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12163}
12164
12166{
12167 return myNPbase->muTHUZHmumu(sqrt_s);
12168}
12169
12170muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12171: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12172{
12173 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12174 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12175}
12176
12178{
12179 return myNPbase->muTHUWHmumu(sqrt_s);
12180}
12181
12182muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12184{
12185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12186 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12187}
12188
12190{
12191 return myNPbase->muTHUVHmumu(sqrt_s);
12192}
12193
12194muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12195: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12196{
12197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12198 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12199}
12200
12202{
12203 return myNPbase->muTHUttHmumu(sqrt_s);
12204}
12205
12206muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12208{
12209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12210 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12211}
12212
12214{
12216}
12217
12218muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12219: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12220{
12221 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12222 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12223}
12224
12226{
12228}
12229
12230muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12231: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12232{
12233 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12234 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12235}
12236
12238{
12239 return myNPbase->muTHUZHtautau(sqrt_s);
12240}
12241
12242muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12243: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12244{
12245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12246 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12247}
12248
12250{
12251 return myNPbase->muTHUWHtautau(sqrt_s);
12252}
12253
12254muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12256{
12257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12258 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12259}
12260
12262{
12263 return myNPbase->muTHUVHtautau(sqrt_s);
12264}
12265
12266muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12267: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12268{
12269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12270 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12271}
12272
12274{
12276}
12277
12278muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12279: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12280{
12281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12282 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12283}
12284
12286{
12287 return myNPbase->muTHUggHbb(sqrt_s);
12288}
12289
12290muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12291: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12292{
12293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12294 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12295}
12296
12298{
12299 return myNPbase->muTHUVBFHbb(sqrt_s);
12300}
12301
12302muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12303: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12304{
12305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12306 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12307}
12308
12310{
12311 return myNPbase->muTHUZHbb(sqrt_s);
12312}
12313
12314muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12315: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12316{
12317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12318 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12319}
12320
12322{
12323 return myNPbase->muTHUWHbb(sqrt_s);
12324}
12325
12326muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12327: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12328{
12329 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12330 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12331}
12332
12334{
12335 return myNPbase->muTHUVHbb(sqrt_s);
12336}
12337
12338muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12340{
12341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12342 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12343}
12344
12346{
12347 return myNPbase->muTHUttHbb(sqrt_s);
12348}
12349
12350
12351muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12352: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12353{
12354 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12355 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12356}
12357
12359{
12360
12361 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12362
12363}
12364
12365muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12367{
12368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12369 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12370}
12371
12373{
12374
12375 return (myNPbase->muTHUVBFHinv(sqrt_s));
12376
12377}
12378
12379
12380muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12381: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12382{
12383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12384 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12385}
12386
12388{
12389
12390 return (myNPbase->muTHUVHBRinv(sqrt_s));
12391
12392}
12393
12394muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12395: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12396{
12397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12398 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12399}
12400
12402{
12403 return (myNPbase->muTHUVHinv(sqrt_s));
12404}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1850
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1774
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4053
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3658
virtual const double cbminuscc() const
Definition: NPbase.h:2847
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:3033
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4328
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2031
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4418
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2472
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1162
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3949
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2997
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2923
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2580
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3093
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4064
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1645
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3438
virtual const double cVpluscb() const
Definition: NPbase.h:2829
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2035
double C1HZZ
Definition: NPbase.h:5685
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3958
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1383
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1754
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1137
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4125
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4211
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4043
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3484
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1954
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1418
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1113
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2222
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4157
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1523
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1212
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3533
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1559
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2140
virtual const double muttHgagaZeeboost(const double sqrt_s) const
The ratio in the , channel channel in the current model and in the Standard Model.
Definition: NPbase.h:1582
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1721
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1661
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1822
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2935
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3687
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1790
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4310
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3835
virtual const double ccminusctau() const
Definition: NPbase.h:2865
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2947
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4202
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3563
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1786
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4445
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1701
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1927
virtual const double cgaplusct() const
Definition: NPbase.h:2811
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3098
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2907
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2017
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1246
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1778
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3475
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4427
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4147
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2212
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1463
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4166
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3108
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1950
virtual const double delta2sBRH3(const double C1prod, const double C1Hxx) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for in the...
Definition: NPbase.h:2730
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2887
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2927
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2931
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3844
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4107
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1810
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2160
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4220
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4256
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3001
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3513
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4283
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1677
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2977
virtual const double cgplusct() const
Definition: NPbase.h:2802
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1842
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3798
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2903
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1475
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3081
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4076
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1734
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1742
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4364
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1649
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1762
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2049
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1281
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3931
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3811
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4247
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3771
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2373
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2337
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2315
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1587
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1882
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1332
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3871
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1605
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3667
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2232
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:2008
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3853
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2022
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4319
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4355
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3726
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3677
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3085
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3707
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2968
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1886
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3113
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2659
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1945
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1653
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2026
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3457
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1780
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1766
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1750
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1689
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4472
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:2004
double C1Htautau
Definition: NPbase.h:5684
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1977
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2895
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3553
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1673
double C1Hbb
Definition: NPbase.h:5684
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2067
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1896
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3697
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1257
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1905
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3994
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1986
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2993
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3762
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2087
double C1Hgg
Definition: NPbase.h:5685
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2202
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3572
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1657
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3069
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1814
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1697
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3017
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1488
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1680
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3862
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2077
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2709
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2899
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2589
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3428
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1782
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1175
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1758
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1846
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4481
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1862
double C1Hcc
Definition: NPbase.h:5684
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2053
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3649
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1770
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4089
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4021
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3744
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3780
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1830
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2883
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1999
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2989
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1995
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1593
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3013
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3985
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1345
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3899
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2305
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1941
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1629
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2793
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1830
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2610
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3581
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1633
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3819
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3609
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2679
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4490
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2182
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4003
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1705
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1499
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1511
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3493
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4032
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2262
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1858
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4175
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1187
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3466
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2766
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:3029
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3976
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4373
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3118
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2170
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4012
virtual const double delta2sH3(const double C1) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for an obse...
Definition: NPbase.h:2721
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3061
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2956
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1738
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4184
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4229
double C1Hgaga
Definition: NPbase.h:5685
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1630
virtual const double cbminusctau() const
Definition: NPbase.h:2856
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2641
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1407
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2150
double C1Hss
Definition: NPbase.h:5684
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2382
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1150
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2972
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1713
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2775
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3021
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4116
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1200
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3967
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2097
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2107
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2670
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1599
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1866
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1746
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2943
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1102
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3523
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1571
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3543
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2964
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3735
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1990
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1834
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:3049
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2120
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3910
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4265
double C1HZga
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5685
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2242
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3753
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2526
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3103
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1854
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2130
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2878
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1870
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4436
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2952
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1641
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3073
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2891
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1794
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1681
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1693
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2013
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1235
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4508
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1730
double C1HWW
Definition: NPbase.h:5685
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1685
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2689
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1818
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1802
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3922
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1669
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2632
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2981
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4292
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3629
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4391
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2699
double C1Hmumu
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5684
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3827
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2295
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1826
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3089
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1371
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1395
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1909
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3448
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4136
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4400
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1451
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3123
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3503
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3889
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1535
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4301
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1838
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2619
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2481
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1665
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:3057
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2275
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1625
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4193
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3940
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2784
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2911
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2192
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3005
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2252
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1307
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1923
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1798
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3717
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:3041
virtual const double cgminuscga() const
Definition: NPbase.h:2820
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3416
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1900
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2939
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4238
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3065
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1268
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1890
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3600
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3619
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1125
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1620
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2650
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1091
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1981
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4499
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1726
virtual const double cVplusctau() const
Definition: NPbase.h:2838
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3009
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3789
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1224
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1914
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:3053
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1730
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4382
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1918
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1874
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1717
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2915
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1429
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4454
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1358
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3077
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:3037
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4337
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1319
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3639
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2960
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4409
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1806
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1637
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1878
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:3045
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4463
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3591
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2285
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:3025
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1709
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3880
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2985
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1547
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4274
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2919
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgagaZeeboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
const NPbase * myNPbase
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase